代码随想录算法训练营第八天 |LeetCode344反转字符串 541反转字符串Ⅱ 剑指Offer05替换空格 151反转字符串中的单词 剑指Offer 58左旋转字符串

1.反转字符串(力扣)

双指针，一个指向字符串尾，一个指向开头，两两交换即可

void reverseString(char* s, int sSize){
    int left=0,right=sSize-1;
    while(right>left)
    {
        char temp=s[left];
        s[left]=s[right];
        s[right]=temp;
        right--;
        left++;
    }
}

2.反转字符串Ⅱ(力扣)

与上一个题类似，只不过变成了区间内的翻转字符串，每隔2k个字符就翻转前k个字符，重复第1题的步骤即可。最后对于剩余的判断长度也可以重复上述操作。

char * reverseStr(char * s, int k){
    int length=strlen(s);
    int times=length/(2*k);
    int rest=length%(2*k);
    for(int i=0;i<times;i++)
    {
        int left=i*2*k;
        int right=left+k-1;
        while(right>left)
        {
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            left++;
            right--;
        }
    }
    if(rest<k)
    {
        int left=times*2*k;
        int right=length-1;
        while(left<right)
        {
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            right--;
            left++;
        }
    }
    else if(rest>=k)
    {
        int left=times*2*k;
        int right=left+k-1;
        while(left<right)
        {
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            right--;
            left++;
        }
    }
    return s;
}

3.剑指Offer05 替换空格(力扣)

将每个空格替换成'%20'，那就有两种想法，一种是开辟新的长度从前向后填充，每次遇到空格就用字符串替换：

char* replaceSpace(char* s){
    int length=strlen(s);
    int count=0;
    for(int i=0;i<length;i++)
    {
        if(s[i]==' ')
        {
            count++;
        }
    }
    char *replace=(char *)malloc(sizeof(char)*(length+2*count)+1);
    int flag=0;
    for(int i=0;i<length;i++)
    {
        if(s[i]==' ')
        {
            replace[i+flag]='%';
            replace[i+flag+1]='2';
            replace[i+flag+2]='0';
            flag+=2;
        }
        else
        {
            replace[i+flag]=s[i];
        }
    }
    replace[length+2*count]='\0';
    return replace;
}

第二种想法则是从后向前填充，这样可以不用再次开辟新的数组，而是开辟长度后进行填充（更加常用）

char* replaceSpace(char* s){
    //统计空格数量
    int count = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] == ' ') {
            count++;
        }
    }

    //为新数组分配空间
    int newLen = len + count * 2;
    char* result = malloc(sizeof(char) * newLen + 1);
    //填充新数组并替换空格
    for (int i = len - 1, j = newLen - 1; i >= 0; i--, j--) {
        if (s[i] != ' ') {
            result[j] = s[i];
        } else {
            result[j--] = '0';
            result[j--] = '2';
            result[j] = '%';
        }
    }
    result[newLen] = '\0';

    return result;
}

4.反转字符串中的单词(力扣)

主要分三步：

1.删除多余的空格

        对于开头部分的，用快指针从开头遍历，直到到达非空格的字符。

        对于中间单词间冗余的空格，则是用相邻的两个字符进行判断，如果相邻的均为空格就跳过，否则将快指针的值赋给慢指针。

        对于结尾的空格，由于设置的条件是length-1，直接判断快指针指向的值是否为空格，不为空格赋值之后让慢指针变为'\0'，手动改变字符串的长度；如果为空格直接让慢指针为'\0'。

2.翻转字符串：双指针同开始的两个题

3.翻转每个单词：遇到空格重复双指针翻转

char * reverseWords(char * s){
    int length=strlen(s);
    int slow=0,fast=0;
    while(s[fast]==' ')
    {
        fast++;
    }//去开头空格
    while(fast<length-1)
    {
        if(s[fast]==s[fast+1]&&s[fast]==' ')
        {
            fast++;
        }
        else
        {
            s[slow++]=s[fast++];
        }
    }
    if(s[fast]==' ')
    {
        s[slow]='\0';
    }
    else
    {
        s[slow++]=s[fast];
        s[slow]='\0';
    }
    int left=0,right=slow-1;
    while(right>left)
    {
        char temp=s[right];
        s[right]=s[left];
        s[left]=temp;
        left++;
        right--;
    }
    int flag=0;
    left=0;
    while(flag<slow)
    {
        if(s[flag]==' ')
        {
            right=flag-1;
            while(left<right)
            {
                char temp=s[left];
                s[left]=s[right];
                s[right]=temp;
                right--;
                left++;
            }
            left=flag+1;
        }
        flag++;
    }
    right=slow-1;
    while(left<right)
    {
        char temp=s[left];
        s[left]=s[right];
        s[right]=temp;
        left++;
        right--;
    }
    return s;
}

5.左旋转字符串(力扣)

开辟一个新的空间用于储存前n个字符，然后快慢指针将前length-n个数进行替换，再见新开辟的数组里面的值替换到最后。

char* reverseLeftWords(char* s, int n){
    char *store=(char*)malloc(sizeof(char)*n);
    int length=strlen(s);
    for(int i=0;i<n;i++)
    {
        store[i]=s[i];
    }
    int slow=0,fast=n;
    for(;fast<length;fast++,slow++)
    {
        s[slow]=s[fast];
    }
    for(int i=0;i<n;i++)
    {
        s[slow+i]=store[i];
    }
    return s;
}