3-5 项目开发字符串模型

最新推荐文章于 2024-09-15 11:40:06 发布

QQ960054653

最新推荐文章于 2024-09-15 11:40:06 发布

阅读量87

点赞数

分类专栏： C语言文章标签： c++ 算法 c语言

本文链接：https://blog.csdn.net/QQ960054653/article/details/125625786

版权

C语言专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1、strstr-whiledowhile模型

#include <stdio.h>
#include<string.h>
#include<stdlib.h>



int main02(int argc, char *argv[])
{
    int ncount = 0;
    char *p= "abcd1234abcd1234kdabcdkdj873abcd321";//求字符串中abcd出现的次数

    while((p = strstr(p,"abcd"))!='\0')
    {
        ncount++;
        p += strlen("abcd");
        printf("p:%s\n",p);
        if(*p == NULL)
        {
            break;
        }
    }

    printf("ncount:%d",ncount);
    printf("Hello World!\n");
    return 0;
}
int main01(int argc, char *argv[])
{
    char *p= "abcd1234abcd1234kdabcdkdj873abcd321";//求字符串中abcd出现的次数
    int ncount = 0;
    do
    {
       p = strstr(p,"abcd");
       if(p != NULL)
       {
           ncount++;
           p += strlen("abcd");
           printf("p:%s\n",p);
       }
       else
       {
           break;
       }
    }while(*p != '\0');
    printf("ncount:%d",ncount);



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

int getCount(char *mystr,char *sub,int *ncount)
{
    char *tmpMystr = mystr;
    char *tmpSub   = sub;
    int tmpCount = 0;
    if(mystr == NULL||sub == NULL)
    {
        return -1;
    }

    while((mystr = strstr(mystr,sub))!='\0')
    {
        tmpCount++;
        mystr += strlen(sub);
        printf("mystr:%s\n",mystr);
        if(*mystr == NULL)
        {
            break;
        }
    }
    *ncount = tmpCount;
    return 0;
}
int main(int argc, char *argv[])
{
    char *p= "abcd1234abcd1234kdabcdkdj873abcd321";//求字符串中abcd出现的次数
    char *mysub = "abcd";
    int ncount = 0;
    int ret = getCount(p,mysub,&ncount);
    printf("ncount:%d\n",ncount);



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

2、两头堵模型

#include <stdio.h>
#include<string.h>
#include<stdlib.h>


int getCount(char *mystr,int *ncount)
{
    char *tmpMystr = mystr;

    int i = 0;
    int j = 0;
    int tmpCount = 0;
    if(mystr == NULL || ncount == NULL)
    {
        return -1;
    }
    //假设是"123456" strlen=6  下标从0开始 就是0-5 所以-1，变成5更合适
    j =strlen(tmpMystr) - 1;//因为下标是从0开始的 -1，

    //isspace若参数c为空格字符，则返回非0，否则返回0。
    while(isspace(tmpMystr[i]) && tmpMystr[i] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        //走到非空格的时候就不走了
        i++;
    }
    while(isspace(tmpMystr[j]) && tmpMystr[j] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        j--;
    }

    tmpCount = j-i+1;
    *ncount = tmpCount;
    return 0;
}

//取出字符串的前后空格,中间的不进行处理
int trimSpace(char *mystr,char *newStr)
{
    char *tmpMystr = mystr;

    int i = 0;
    int j = 0;
    int tmpCount = 0;
    if(mystr == NULL || newStr == NULL)
    {
        return -1;
    }
    //假设是"123456" strlen=6  下标从0开始 就是0-5 所以-1，变成5更合适
    j =strlen(tmpMystr) - 1;//因为下标是从0开始的 -1，

    //isspace若参数c为空格字符，则返回非0，否则返回0。
    while(isspace(tmpMystr[i]) && tmpMystr[i] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        //走到非空格的时候就不走了
        i++;
    }
    while(isspace(tmpMystr[j]) && tmpMystr[j] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        j--;
    }
    tmpCount = j-i+1;
    strncpy(newStr,tmpMystr+i/*i,shi */,tmpCount);
    //这个地方特别容易漏掉
    newStr[tmpCount]='\0';
    return 0;
}


//取出字符串的前后空格,中间的不进行处理，不开辟新的内存空间
//前提是  这个内存空间可以被修改
int trimSpace_new(char *mystr)
{
    char *tmpMystr = mystr;

    int i = 0;
    int j = 0;
    int tmpCount = 0;
    if(mystr == NULL)
    {
        return -1;
    }
    //假设是"123456" strlen=6  下标从0开始 就是0-5 所以-1，变成5更合适
    j =strlen(tmpMystr) - 1;//因为下标是从0开始的 -1，

    //isspace若参数c为空格字符，则返回非0，否则返回0。
    while(isspace(tmpMystr[i]) && tmpMystr[i] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        //走到非空格的时候就不走了
        i++;
    }
    while(isspace(tmpMystr[j]) && tmpMystr[j] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        j--;
    }
    tmpCount = j-i+1;
    strncpy(mystr,tmpMystr+i/*i,是因为前边的空格 */,tmpCount);
    //这个地方特别容易漏掉
    tmpMystr[tmpCount]='\0';
    *mystr = *tmpMystr;
    return 0;
}


int main(int argc, char *argv[])
{
    char *p= "    abcd123 45  ";//求字符串中非空格的次数，这个字符串再内存的全局区
    char buf[1024] =  "    abcd123 45  ";
    int i = 0;
    int j = 0;
    int ncount = 0;
    char *myNewStr = (char*)malloc(100);
    //假设是"123456" strlen=6  下标从0开始 就是0-5 所以-1，变成5更合适
    j =strlen(p) - 1;//因为下标是从0开始的 -1，

    //isspace若参数c为空格字符，则返回非0，否则返回0。
    while(isspace(p[i]) && p[i] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        //走到非空格的时候就不走了
        i++;
    }
    while(isspace(p[j]) && p[j] !='\0')
    {
        //当字符串不是空格的时候 进入循环体
        j--;
    }

    ncount = j-i+1;

    printf("ncount:%d\n",ncount);
    printf("----------------------------------\n");

    getCount(p,&ncount);
    printf("ncount:%d\n",ncount);
    printf("----------------------------------\n");
    trimSpace(p,myNewStr);
    printf("myNewStr:%s\n",myNewStr);
    printf("----------------------------------\n");
//    trimSpace_new(p);//p只能读不能写   出错。。。。。
//    printf("NewStr:%s\n",p);
    trimSpace_new(buf);//buf可读可写
    printf("NewStr:%s\n",buf);



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

3、字符串反转模型

#include <stdio.h>
#include<string.h>
#include<stdlib.h>


//全局变量
int  g_buf[100];

int inverse01(char *mystr)
{
    int length = strlen(mystr);
    char *p1 = mystr;//指向开头
    char *p2 = mystr+ length -1;//指向结尾

    while(p1<p2)
    {
        char c = *p1;
        *p1 = *p2;
        *p2 = c;
        ++p1;
        --p2;
    }
}

int main01(int argc, char *argv[])
{
    char buf[]= "abcd12345";//字符串反转
    inverse01(buf);
    printf("buf:%s\n",buf);



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


//通过递归的方式 逆向打印
//递归和全局变量（把逆序的结果放入全局变量）
//递归和非局变量（递归指针做函数参数）


//递归比较重要的2个点
//参数的入栈模型
//函数的嵌套调用返回流程
int inverse02(char *mystr)
{
   if(mystr == NULL)//递归结束的异常条件
   {
       return -1;
   }
   if(*mystr == '\0')//递归结束的条件
   {
       return;
   }
   inverse02(mystr + 1);//此时没有执行打印，而是执行了 让 a b c d入栈
   printf("%c ",*mystr);
   return 0;
}

int inverse03(char *mystr)//把逆序的结果返回出来
{
   if(mystr == NULL)//递归结束的异常条件
   {
       return -1;
   }
   if(*mystr == '\0')//递归结束的条件
   {
       return;
   }
   inverse02(mystr + 1);//此时没有执行打印，而是执行了 让 a b c d入栈
//   printf("%c ",*mystr);
   strncat(g_buf,mystr,1);//C库函数strcat()函数的功能是实现字符串的拼接
   return 0;
}

int main03(int argc, char *argv[])
{
    char buf[]= "abcd12345";//字符串反转
    memset(g_buf,0,sizeof(g_buf));

//    inverse02(buf);
//    printf("buf02:%s\n",buf);

    inverse03(buf);
    printf("%s\n",g_buf);

    printf("Hello World!\n");

    return 0;
}

int inverse04(char *mystr,char *buf123)//把逆序的结果返回出来
{
   if(mystr == NULL||buf123 == NULL)//递归结束的异常条件
   {
       return -1;
   }
   if(*mystr == '\0')//递归结束的条件
   {
       return;
   }
   inverse04(mystr + 1,buf123);//此时没有执行打印，而是执行了 让 a b c d入栈
//   printf("%c ",*mystr);
   strncat(buf123,mystr,1);//C库函数strcat()函数的功能是实现字符串的拼接
   return 0;
}


int main(int argc, char *argv[])
{
    char buf[]= "abcd12345";//字符串反转

    memset(g_buf,0,sizeof(g_buf));



    {
        char mybuf[1024]={0};
        inverse04(buf,mybuf);
        printf("%s\n",mybuf);

    }

    printf("Hello World!\n");

    return 0;
}