---

一、重新格式化字符串

点我直达~

思路1：构造模拟

• 1.遍历字符串，将数字字符和字母字符分别放在不同的字符串
• 2.如果|字母字符数量 - 数字字符数量| > 1 ，则无法实现格式化，返回""
• 3.如果不是2.中的情况，则偶数为字符必须放数量多的字符串对应的字符（下标从0开始）。
• 将数量多的字符串对应的字符和数量少的字符串对应的字符交叉逐个放回到原字符串即可。

具体代码如下：

class Solution {
public:
    string reformat(string s) 
    {
        string letter,num;
        for(int i = 0;i<s.size();++i)
        {
            if(s[i] >= 'a' && s[i] <='z')
                letter+=s[i];
            else
                num+=s[i];
        }
        

        int lenl = letter.size();
        int lenn = num.size();

        //字母个数和数字个数的差值大于1，不管怎么排，都一定有连续的类型出现
        if(abs(lenl - lenn) > 1 )
            return "";

        int i = 0,numi = 0,letteri = 0;
        while(i < s.size())            
        {
            if(letter.size() > num.size())
            {
                s[i++] = letter[letteri++];
                s[i++] = num[numi++];
            }
            else
            {
                s[i++] = num[numi++];
                s[i++] = letter[letteri++];
            }
        }
        return s;
    }
};

时间复杂度O(n)，空间复杂度O(n)

---

思路2：双指针法

• 1.遍历字符串，将数字字符和字母字符分别放在不同的字符串
• 2.如果|字母字符数量 - 数字字符数量| > 1 ，则无法实现格式化，返回""
• 3.字符数量多的字符串有优先权，偶数位必须放字符数量多的字符，（下标从0开始），下标分别记为i = 0,j = 1
• 4.遍历s,如果s[i]不是数量多的字符，则从j开始往后遍历，知道找到第一个是数量多的字符，与s[i]叫交换
• 5.依次往后遍历，直到 i到末尾结束。

具体代码如下：

    string reformat(string s) 
    {
        // //法2：双指针
        
        // //1.遍历字符串，计算数字和字符分别有多少
        int lend = 0,lena = 0;
        for(int i = 0;i<s.size();++i)
        {
            if(s[i] >='0' && s[i]<='9')
                ++lend;
        }
        lena = s.size() - lend;

        //字母个数和数字个数的差值大于1，不管怎么排，都一定有连续的类型出现
        if(abs(lend-lena) > 1)
            return "";

        //字符多的要放在第一位
        bool flag = lend > lena;

        for(int i = 0,j = 1;i<s.size();i+=2)
        {
            //如果偶数位不是放数量多的，那就要从奇数位开始找这个数量多的字符
            //下标从0开始
            if(isdigit(s[i]) != flag)
            {
                while(j<s.size())
                {
                    if(isdigit(s[j]) == flag)
                    {
                        swap(s[i],s[j]);
                        break;
                    }

                    j+=2;
                }
            }
        }
        return s;
    }
};

二、字符串压缩

点我直达~

思路1：简单替换

• 1.开辟一块同S大小的空间，遍历S字符串，如果S[i] !=S[i+1]或者i == S.size() -1，说明下标遇到了某一个相同子串的终点或者遇到字符串末尾，此时将对应的子串的字符和长度追加到开辟好的字符串s中。
• 2.如果新开辟的字符串长度大于原来的字符串，则压缩失败，返回原来的字符串。
• 3.否则返回新的字符串

具体代码如下：

//写了这道题才发现有一个函数叫做to_string(),将任意一个东西转成字符串
//
class Solution {
public:
    string compressString(string S)
    {
        string s;
        int len = 0;
        for (int read = 0; read < S.size(); ++read)
        {
            ++len;
            if (S[read] != S[read + 1] || read == S.size() - 1)
            {
                s +=S[read];
                s += (to_string(len));
                len = 0;
            }

        }
	
	return S.size() > s.size()? s:S ; 
	
    }
};

时间复杂度O（n），空间复杂度O（n）

总结

• 1.今天写得两道字符串的题目，其中一道题目是关于字符串的压缩的，对于这道题，刚开始绞尽脑汁都不知道如何原地覆盖原字符串，后来发现好像也不用这样原地覆盖，第二个出现的问题是，如果某个字符出现的次数大于10次该怎么处理。在这里我已经被之前写过的一道类似的压缩字符串的题目给洗脑了，用了短除法存储，再逆置，但是我不会啊。。后面发现之前写的题是将字符的长度放在顺序表中的，而这道题是直接用string构造的，可以调用operator+=，终于解决了这道题。

• 2.关于字符串的重新格式化，这道题比较好解决，可以使用双指针，还可以用模拟构造两个字符串空间来进行存储，直接就过了哈哈。