C++字符串反轉(zhuǎn)的幾種方法

更新時間：2021年06月30日 11:00:06 作者：lemaden

通過不同的方法，實現(xiàn)對所輸入字符串的反轉(zhuǎn)，具有一定的參考價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

通過不同的方法，實現(xiàn)對所輸入字符串的反轉(zhuǎn)，可以很好地復(fù)習(xí)鞏固 C++ 基礎(chǔ)知識

/*分析過程:
　　假設(shè)要使傳遞的字符串為常量const字符串,這樣操作更加靈活,可直接傳遞字符串字面值進行反轉(zhuǎn),常見的解決方法就是,定義一個新的與傳遞過來字符串長度
　　相等的字符數(shù)組,然后進行字符串拷貝,把str字符按從左到右放置到字符數(shù)組中,然后采用循環(huán)來對字符數(shù)組中字符反轉(zhuǎn)
*/
/*第一種,采用以上思路解法,傳遞為const類型C風(fēng)格字符指針,返回為char*類型*/
//直接使用字符數(shù)組賦值
char* strrev1(const char* str)
{
 　　const size_t length = strlen(str);//求字符長度
 　　char *temp = new char[length];//新建一個等長度的字符數(shù)組
 　　strcpy(temp,str);//字符串拷貝
 　　for (size_t i = 0; i <= length/2; ++i)//對字符數(shù)組中的字符反轉(zhuǎn),循環(huán)執(zhí)行條件為標(biāo)識小于或等于字符長度一半
 　　{
  　　　　char c = temp[i];
 　　　　 temp[i] = temp[length - i -1];
  　　　　temp[length - i -1] = c;
 　　}
 　　return temp;//返回反轉(zhuǎn)后的字符
}

//采用指針操作方式
char* strrev2(const char* str)
{
 　　char* tmp = new char[strlen(str)];
 　　strcpy(tmp,str);
 　　char* ret = tmp;//用來最后返回數(shù)組指針
 　　char* p = tmp + strlen(str) - 1;
 　　while (p > tmp)
 　　{
  　　　　char t = *tmp;
 　　　　 *tmp++ = *p;
 　　　　 *p-- = t;
　　 }
 　　return ret;
}

//與上一函數(shù)基本相似,只不過本函數(shù)使用是移位操作改變字符指針指向

char* strrev3(const char* str)
{
 　　char* tmp = new char[strlen(str) + 1];
 　　strcpy(tmp,str);
 　　char* ret = tmp;
 　　char* p = tmp + strlen(str) - 1;
 　　while (p > tmp)
　　 {
 　　　　 *p ^= *tmp;
  　　　　*tmp++ ^= *p;
  　　　　*p-- ^= *tmp;
 　　}
 　　return ret;
}

//節(jié)省幾步,直接給新建的字符數(shù)組賦反轉(zhuǎn)的值,呵呵,簡單明了,只不過循環(huán)多執(zhí)行幾次

char* strrev4(const char* str)
{
 　　char * temp = new char[strlen(str)];
 　　for(int i = 0; i <= strlen(str); i++)
 　　{
  　　　　temp[i] = str[strlen(str) - i -1];
 　　}
　　 return temp;
}

不能直接反轉(zhuǎn)常量字符串,因為沒有定義新的字符數(shù)組,而是在原數(shù)組上直接進行字符反轉(zhuǎn),節(jié)省空間,提高效率,還要傳遞字符長度,增加限制,但總歸是個思路)

char* strrev5 (char* str,int len)
{
 　　if (len <= 1)
 　　　　 return str;
 　　char t = *str;
 　　*str = *(str + len -1);
 　　*(str + len -1) = t;
 　　return (strrev5(str + 1,len - 2) - 1);
}

/*如果傳遞是std::string類型字符串且是const的!!
　　返回類型為std::string
*/
std::string strrev6(const std::string str)
{
　　string r ;//定義一個新的字符串變量,用來接收
　　string r;
 　　for(int i = 0; i < str.length(); ++i)
 　　{
  　　　　r = str[i] + r;//注意順序
 　　}
　　return r;
}

/*如果傳遞是std::string類型字符串,但不是const的!!
　　返回類型為std::string,那你將不必再定義一個新的字符串變量
　　節(jié)省空間,注意:string類型可以直接接受字符串字面值就是啦..
*/ 


std::string strrev6(std::string str)
{
　　for(int i = 0; i <= str.length()/2; ++i)
 　　{
 　　　　 char c = str[i];
 　　　　 str[i] = str[str.length() - i -1];
  　　　　str[str.length() - i - 1] = c;
 　　　　}
 　　return str;
}

string類常用的構(gòu)造函數(shù)有:

string str;        //生成一個空字符串

string str ("ABC")  //等價于 str="ABC"<br>
string str ("ABC", strlen)  // 將"ABC"存到str里,最多存儲前strlen個字節(jié)

string s("ABC",stridx,strlen)   //將"ABC"的stridx位置,做為字符串開頭,存到str里.且最多存儲strlen個字節(jié).

string s(strlen, 'A')  //存儲strlen個'A'到str里

string類常用的成員函數(shù)有:

str1.assign("ABC");　　　　　　　　//清空string串,然后設(shè)置string串為"ABC"

str1.length()；                 //獲取字符串長度

str1.size();　　　　　　　　　　　 //獲取字符串?dāng)?shù)量,等價于length()

str1.capacity();　　　　　　　　  //獲取容量,容量包含了當(dāng)前string里不必增加內(nèi)存就能使用的字符數(shù)

str1.resize(10);　　　　　　     //表示設(shè)置當(dāng)前string里的串大小,若設(shè)置大小大于當(dāng)前串長度,則用字符\0來填充多余的.
str1.resize(10,char c);　　　　 //設(shè)置串大小，若設(shè)置大小大于當(dāng)前串長度,則用字符c來填充多余的

str1.reserve(10);　　　　　　　　　//設(shè)置string里的串容量,不會填充數(shù)據(jù).
str1.swap(str2);        　　    //替換str1 和 str2 的字符串

str1.puch_back ('A');    　　//在str1末尾添加一個'A'字符,參數(shù)必須是字符形式

str1.append ("ABC");     　　//在str1末尾添加一個"ABC"字符串,參數(shù)必須是字符串形式

str1.insert ("ABC",2);       //在str1的下標(biāo)為2的位置,插入"ABC"

str1.erase(2);         　　　　//刪除下標(biāo)為2的位置,比如: "ABCD" --> "AB"

str1.erase(2,1);              //從下標(biāo)為2的位置刪除1個,比如: "ABCD"  --> "ABD"

str1.clear();           　　 //刪除所有

str1.replace(2,4, "ABCD"); //從下標(biāo)為2的位置,替換4個字節(jié),為"ABCD"

str1.empty();         　　 //判斷為空, 為空返回true/*assign() :賦值函數(shù) ,里面會重新釋放分配字符串內(nèi)存 */
　 str1.assign("HELLO");                   //str1="HELLO"
　　str1.assign("HELLO", 4);                //str1="HELL" ,只保留4個字符
　　str1.assign("HELLO", 2, 3);             //str1="LLO"    ,從位置2開始,只保留3個字符
　　str1.assign(5, 'c');                    //str1="CCCCC"             //按字符賦值

const char* c_str();

返回一個常量C字符串, 內(nèi)容與本string串相同.

注意:當(dāng)本string的內(nèi)容改變,或被析構(gòu)后,返回的字符串也不會被改變,因為返回的字符串是從新通過new char[]出來.

參考下面代碼,可以發(fā)現(xiàn)返回的C字符串地址和string里的字符串地址完全不同:

string* str = new string("ASD"); //str="ASD"
const char* c = str->c_str();

cout<<c<<endl;                 //打印 : "ASD"

printf("&c[0]=%p,&str[0]=%p\n",&c[0],&str[0]);
                          //打印:c=0x94bf024,&str[0]=0x94bf008

str->append("dd");            //str="ASDdd"
cout<<c<<endl;                //打印 : "ASD"

delete str;                  //調(diào)用析構(gòu)

cout<<c<<endl;               //打印 : "ASD"

反轉(zhuǎn)相關(guān)(位于頭文件<algorithm>)

string str("hello");
reverse(str.begin(),str.end());
cout<< str <<endl;              //反轉(zhuǎn)自身字符串,打印olleh

查找相關(guān):

string str("ABCDEFGABCD");                      //11個字符
int n;<br>
/*查找成功返回位置,查找失敗,則n等于-1*/
/*find():從頭查找某個字符串*/
n= str.find('A');              //查找"A",n=0;
n= str.find("AB");             //查找"AB",n=0;
n= str.find("BC",1);           //從位置1處,查找"BC",n=1;
n= str.find("CDEfg",1,3);      //從位置1處,查找"CDEfg"的前3個字符,等價于str.find("CDE",1),n=2;

/*rfind():反向(reverse)查找,從末尾處開始,向前查找*/
n= str.rfind("CD");           //從位置10開始向前查找,n=9
n= str.rfind("CD",5);         //從位置5開始向前查找,n=2
n= str.rfind("CDEfg",5,3);    //等價于str.rfind("CDE",5);       ,所以n=2


/* find_first_of ():查找str里是否包含有子串中任何一個字符*/
n= str.find_first_of("abcDefg");     //由于str位置3是'D',等于"abcDefg"的'D',所以n=3
n= str.find_first_of("abcDefg",1,4); //等價于str. find_first_of ("abcD",1); 所以n=3


/* find_last_of ():末尾查找, 從末尾處開始,向前查找是否包含有子串中任何一個字符*/
n= str.find_last_of("abcDefg");      //由于str末尾位置10是'D',所以n=10
n= str.find_last_of("abcDefg",5,4);  //等價于str. find_last_of ("abcD",5); 所以n=3


/* find_first_not_of ():匹配子串任何一個字符,若某個字符不相等則返回str處的位置,全相等返回-1*/
n= str.find_last_not_of("ABC");    //由于str位置3'D',在子串里沒有,所以 n=3
n= str.find_last_not_of("aABDC");  //由于str位置4 'F',在子串里沒有,所以 n=4
n= str.find_last_not_of("aBDC");   //由于str位置0 'A',在子串里沒有,所以 n=0
<br>
/* find_last_not_of ():反向匹配子串任何一個字符,若某個字符不相等則返回str處的位置,全相等返回-1*/
n= str.find_last_not_of("aBDC");  //由于str位置7'A',在子串里沒有,所以 n=7

拷貝相關(guān):

str2=str1.substr(2);        //提取子串,提取出str1的下標(biāo)為2到末尾,給str2

str2=str1.substr(2,3);     //提取子串,從 str1的下標(biāo)為2開始,提取3個字節(jié)給str2

const char *s1= str.data();   //將string類轉(zhuǎn)為字符串?dāng)?shù)組,返回給s1
<br>
char *s=new char[10];
str.copy(s,count,pos);    //將str里的pos位置開始,拷貝count個字符,存到s里.

實例1,通過string類實現(xiàn)字符串循環(huán)右移功能

比如: "abcdefg" 循環(huán)右移3位等到: "efgabcd"

代碼如下:

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

string operator >>(const string& str,int n)
{
       string ret;
       n %= str.length();

       ret=str.substr(str.length()-n);              //找到右移的字符串
       ret+=str.substr(0,str.length()-n);

       return ret;
}

int main()
{
       string str="abcdefg";
       string ret= str>>3 ;
       cout<<ret<<endl;

       return 0;
}

實例2,通過string類實現(xiàn)字符串反轉(zhuǎn)

比如: "we;tonight;you" -> "ew;thginot;uoy"

代碼如下:

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;

string reverse_func(const string& str)
{
       int end;
       int start=0;
       int len;
       string ret="";
       string tmp;

      while(1)
      {
         end=str.find(';',start);

         if(end== -1)          //沒找到;
        {
         len=str.length()-start;
         tmp=str.substr(start,len);

         reverse(tmp.begin(),tmp.end());   //反轉(zhuǎn)字符串

         ret+=tmp;

         return ret;
        }
        else               //找到;
        {
         len=end-start;
         tmp=str.substr(start,len);

         reverse(tmp.begin(),tmp.end());     //反轉(zhuǎn)字符串

         ret+=tmp+';';
         start=end+1;
        }

     }

}

int main()
{
       string str("we;tonight;you");

       string ret=reverse_func(str);

       cout<< ret<<endl;

       return 0;
}

練習(xí)題：

要求：用string完成。題目如下：

int main()
{
    cout << reverse("", ';') << endl;                 // 輸出：空字符串
    cout << reverse(";", ';') << endl;                // 輸出：;
    cout << reverse("abcde;", ';') << endl;           // 輸出：edcba;
    cout << reverse("we;tonight;you", ';') << endl;   // 輸出：ew;thginot;uoy

    return 0;
}

參考代碼與思路：

我們觀察，reverse（“”，‘;'）函數(shù)需要傳遞‘;'，說明可能需要查找傳入的字符串是否有 ‘；'，查閱資料得到：

string 類中的確有find 成員函數(shù)的，它的用法如下：

find()：在一個字符串中查找一個指定的單個字符或字符數(shù)組。如果找到，就返回首次匹配的開始位置；如果沒有查找到匹配的內(nèi)容，就返回string::npos。

1.如果是string：：npos 輸出空字符串

2.如果找到了‘；'，而且是在位置1，輸出；字符串

3.find_last_of()：在一個目標(biāo)串中進行查找，返回最后一個與指定字符組中任何字符匹配的字符位置。如果沒有查找到匹配的內(nèi)容，則返回npos。

4.逆轉(zhuǎn)

5.查找到第一個后繼續(xù)往后查找，若count值=2；記錄；的位置

6.取以；為分割的子串，對每個字串逆序。

7.逆序:二分交換，或者用算法模板begin: end

參考博客：https://www.cnblogs.com/lifexy/p/8642163.html