字符串反转模型

类似两头堵模型的字符串反转

int inverse(char *src_str)
{
    int ret = 0;
    int len = strlen(src_str);
    char * head = src_str;
    char * tail = src_str + (len-1);

    char tmp_c = 0;

    if(src_str == NULL){
        ret = -1;
        printf("%s is error!src_str == NULL\n",__FUNCTION__);
        return ret;
    }

    while(head < tail){
        tmp_c = *head;
        *head++ = *tail;
        *tail-- = tmp_c;
    }

    return ret;
}

int main(void)
{
    //char *p = "    abcdefg    ";//不能用字符串常量赋值给一个指针进行该实验，因为常量区不可修改数据
    char buf[1024]="abcdefg";
    int ret = 0;
    ret = inverse(buf);
    if(ret != 0){
        printf("inverse failed!ret : %d\n",ret);
        return ret;
    }
    printf("buf:%s\n",buf);

    printf("Hello World!\n");
    return 0;
}

利用堆栈的字符串反转（递归）

int inverse_02(char *src_str)
{
    int ret = 0;

    char *tmp_p = src_str;

    if(src_str == NULL){//合法性检测
        ret = -1;
        printf("%s is error!src_str == NULL\n",__FUNCTION__);
        return ret;
    }

    if(*tmp_p == '\0')//递归停止的正常条件
    {
        return 0;
    }

    inverse_02(tmp_p+1);//将tmp_p指向的内存空间的数据的地址逐个压栈

    printf("%c",*tmp_p);

    return ret;
}

int main(void)
{

    char buf[1024]="abcdefg";
    int ret = 0;

    printf("buf:");
    ret = inverse_02(buf);
    if(ret != 0){
        printf("inverse_02 failed!ret : %d\n",ret);
        return ret;
    }

    printf("\nHello World!\n");
    return 0;
}

递归结合全局变量

char g_buf[1024]={0};

int inverse_03(char *src_str)
{
    int ret = 0;

    char *tmp_p = src_str;

    if(src_str == NULL){//合法性检测
        ret = -1;
        printf("%s is error!src_str == NULL\n",__FUNCTION__);
        return ret;
    }

    if(*tmp_p == '\0')//递归停止的正常条件
    {
        return 0;
    }

    inverse_03(tmp_p+1);//将tmp_p指向的内存空间的数据的地址逐个压栈

    strncat(g_buf,tmp_p,1);

    return ret;
}

int main(void)
{

    char buf[1024]="abcdefg";
    int ret = 0;


    ret = inverse_03(buf);
    if(ret != 0){
        printf("inverse_03 failed!ret : %d\n",ret);
        return ret;
    }
    printf("g_buf:%s\n",g_buf);
    printf("\nHello World!\n");
    return 0;
}

递归、指针

int inverse_04(char *src_str,char *str_out)
{
    int ret = 0;

    char *tmp_p = src_str;

    if(src_str == NULL || str_out == NULL){//合法性检测
        ret = -1;
        printf("%s is error!(src_str == NULL || str_out == NULL)\n",__FUNCTION__);
        return ret;
    }

    if(*tmp_p == '\0')//递归停止的正常条件
    {
        return 0;
    }

    inverse_04(tmp_p+1,str_out);//将tmp_p指向的内存空间的数据的地址逐个压栈

    strncat(str_out,tmp_p,1);

    return ret;
}

int main(void)
{

    char buf[1024]="abcdefg";
    char res[1024];

    int ret = 0;

    memset(res,0,sizeof(res));


    ret = inverse_04(buf,res);
    if(ret != 0){
        printf("inverse_04 failed!ret : %d\n",ret);
        return ret;
    }
    printf("res:%s\n",res);
    printf("\nHello World!\n");
    return 0;
}

【C++ string字符串反转】
当然string字符串的反转也可以使用上面的方法来实现，此外还可以使用STL文件里的reverse（）函数来实现。

#include <iostream>  
#include <algorithm>  
#include<cstdlib>  
#include<cstring>  
using namespace std;  
int main()  
{  
    string ss = "123456";  
    reverse(ss.begin(),ss.end());  
    cout<<ss<<endl;  
    return 0;  
}  

#include <iostream>  
#include <cstring>  
using namespace std;  

int main()  
{  
    char s[]="hello";  

    strrev(s);  

    cout<<s<<endl;  

    return 0;  
}