【LeetCode刷题笔记-22 767：重构字符串（两种容易理解的方法）】

题目：

1.哈希表+排序+奇偶插空

这是一个比较笨拙但是比较好想的办法，而且实际运行的效率其实也不低。

思路：

1.看到26个字母，还和它出现的个数相关的题目，一般都是用一个数组来暂存它的个数然后再处理。那么我们就思考暂存这个数组之后怎么做。

2.假如我们用一维数组存储了它的出现个数，那么判断最大的那个是否大于>length/2 + 1。因为如果大于这个数，那么就一定会靠在一起。

3.假如满足了2，我们怎么重构这个字符串比较简单呢？比较容易想到，我们可以从拥有最多个数的字母开始处理。不论是对其插空也好，还是取值逐个轮流插入字符串也好，都是不错的方法。这里我觉得奇偶插空比较好使。因为奇数位散列开最大的字母之后，后面的字母按奇数位剩下的位数插孔以及偶数位插空是不可能重复的。

4.然后，问题就出现了！我们要按照元素出现的次数来插空，那就要对该数组进行排序。但是一旦排序，就会丢失原本的位置信息，导致无法推算出这个最大个数对应的是哪个字母。

5.所以，就至少要用二维数组来存储它的对应字母信息和对应个数信息。这样排序之后才不会丢失。于是，为了方便存储，我们很容易就能想到哈希表

6.于是就有了Vector和Pair的嵌套存储方式（虽然我还没有完全弄懂这种方式怎么玩）

该方法的C++代码如下，附带测试：

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<unordered_map>
#include <utility>//pair数组 
using namespace std;

class Solution {
private:
    bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
        return a.second > b.second; // 按照频率从大到小排序
    }
public:
    string reorganizeString(string S) {
        unordered_map<char, int> umap;
        int maxFreq = 0;
        for (char s : S) {
            umap[s]++;
            maxFreq = max(umap[s], maxFreq);
        }
        if (2 * maxFreq - 1 > S.size()) return "";

        vector<pair<int, int> > vec(umap.begin(), umap.end());
    	
        sort(vec.begin(), vec.end(), cmp); // 给频率排个序

        string result(S);
        int index = 0;// 先按奇数位散开
        for (int i = 0; i < vec.size(); i++) {
            while (vec[i].second--) {
                result[index] = vec[i].first;
                index += 2;
                if (index >= S.size()) index = 1; // 奇数位插满了插偶数位
            }
        }
        return result;
    }
};

int main()
{
	string s = "abaab";
	Solution solution;
	string ans = solution.reorganizeString(s);
	cout<<ans<<endl;
}

2.双指针（yyds！）
今天我一开始是想到了双指针的做法的，但是自己举例的时候发现有些字符串是无法完成排序的，就没有细想了。然后翻看评论区的时候，无意之间发现了双指针的做法！然后有些例子不能完成我也明白是为什么了。

我们先来看看双指针的基本思路。
首先我们从头开始设定两个指针，一快一慢。向前遍历，如果遇到相同的字母，则慢指针对应到快指针的位置，快指针往前找到第一个不同的字母，然后和慢指针交换。交换完成之后，慢指针退格，快指针 = 慢指针位置+

但是这样做有一个问题：
比如baaba这个数组，如果你正向运算的话，第一个b是永远不会被交换的，也就无法得出正确解。我想到这里也就停止了。
但是大佬们得出了另一个思路，从反向再运算一次，这样就可以让b做交换了。

最后，再检查相邻字符是否存在相等，不存在则返回。
该方法的时间复杂度也是十分优异的。

PS：
我觉得很遗憾，我居然放弃了这么好的一个算法，没有进一步的去想。
这里就贴上双指针的代码：

class Solution {
public:
    string reorganizeString(string S) {
        int right=0,left=S.size();
        for(int i=1;i<S.size();i++){
            if(S[i]==S[i-1]){
                if(right<=i)
                    right=i;
                for(int j=right+1;j<S.size();j++){
                    if(S[j]!=S[i])
                    {
                        swap(S[j],S[i]);
                        right=j;
                        break;
                    }
                }
            }
        }
        for(int i=S.size()-2;i>0;i--){
            if(S[i]==S[i+1]){
                if(left>=i)
                    left=i;
                for(int j=left-1;j>=0;j--){
                    if(S[j]!=S[i])
                    {
                        swap(S[j],S[i]);
                        left=j;
                        break;
                    }
                }
            }
        }
        for(int i=1;i<S.size();i++){
            if(S[i]==S[i-1])
                return "";
        }
        return S;
    }
};

//作者：KongWation
//链接：https://leetcode-cn.com/problems/reorganize-string/solution/3ci-bian-li-chao-wu-nao-fang-fa-by-kongwation/
//来源：力扣（LeetCode）
//著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

至于题解的大根堆，我觉得没有这两种方法容易想到，而且我堆排序用的也不够熟练，这里就不解析了。