每天更新一道python or C++ leetcode題，力求講解清晰準確，客官們可以點贊或者關注。

題目：

給定一個包含紅色、白色和藍色，一共 n 個元素的陣列，原地對它們進行排序，使得相同顏色的元素相鄰，並按照紅色、白色、藍色順序排列。

此題中，我們使用整數 0、 1 和 2 分別表示紅色、白色和藍色。

注意:
不能使用程式碼庫中的排序函式來解決這道題。

示例:

輸入: [2,0,2,1,1,0]
輸出: [0,0,1,1,2,2]

進階：

• 一個直觀的解決方案是使用計數排序的兩趟掃描演算法。
  首先，迭代計算出0、1 和 2 元素的個數，然後按照0、1、2的排序，重寫當前陣列。
• 你能想出一個僅使用常數空間的一趟掃描演算法嗎？

首先給出直觀的解決方案，也就是進階裡已經寫出來了的。

class Solution:
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        num0 = 0
        num1 = 0
        num2 = 0
        i = 0
        while i < len(nums):
            if nums[i] == 0:
                num0 += 1
            elif nums[i] == 1:
                num1 += 1
            elif nums[i] == 2:
                num2 += 1
            i += 1
        j = 0
        while j < len(nums):
            if num0 > 0:
                nums[j] = 0
                num0 -= 1
            elif num1 > 0:
                nums[j] = 1
                num1 -= 1
            elif num2 > 0:
                nums[j] = 2
                num2 -= 1
            j += 1
        
 

這個演算法的話可以說基本練過leetcode的人都能寫得出。

接下來介紹進階的做法：三向切分。

首先直觀地從名字上去理解演算法。

這個演算法的目的是使的陣列分成3個區間，每個區間的元素是相同的，而且這3個區間按大小排序。

好，知道了演算法的目的，怎麼實現呢？

演算法過程：

1.初始化2個指標，一個指向陣列的開頭-1，一個指向結尾+1

2.zero_end是指的是0的區間的邊界所在的index,two_begin是2的區間的邊界所開始的index.

3.遇到一個0，我們把那個0和nums[++zero_end]交換,注意這個時候zero_end加1了，同時如果是2，也就是最後一個區間的元素，我們需要與two_begin上所在的元素交換，同時two_begin也減去了1，如果是1，也就是中間區間的元素，則跳過。

class Solution
{
	public:
		// 交換兩個數函式 
		void swap(int &a, int &b)
		{
			int temp = a;
			a = b;
			b  = temp;
		} 
		void sortColors(vector<int> &nums)
		{
			int zero_end = -1;
			int two_begin = nums.size();
			int i = 0;
			while (i < two_begin)
			{
				if (nums[i] == 0 && i != ++zero_end)
				{
					swap(nums[i], nums[zero_end]);
				}
				else if (nums[i] == 2 && i != --two_begin)
				{
					swap(nums[i], nums[two_begin]);
				}
				else
					i++;
			} 
		}
};

可能很多人不知道為什麼這樣能夠排序，我這裡稍微講個例子：

[1,...0,...]假設有這麼一個數組，第一位是1，第k位出現了第一個0，根據我們的演算法，我們會跳過1，然後當我們遇到第一個0的時候，我們會把1和0交換，也就是說變成[0,...1,...],這時候i位變成1了，繼續跳過，所以我們的指標能不斷前進。

更強更簡潔的程式碼：

接下來要介紹的演算法，已經超神了。它不是那麼好理解，但它又有三向切分的影子。、

讀程式碼前一定要搞懂：

1.i，j, k 分別指向當前遍歷的陣列的最後一個0，1，2的位置。

比如，當前已處理好的部分陣列是 0 0 0 0 1 1 1 2 2 2 *，那麼i，j，k分別指向最後一個0，1，2。m指向*，*號為待處理元素，

 2.++k的結果是k+1

3.如果i,j,k一樣，則它們對應的賦值則有可能覆蓋對方的賦值。

4.如果沒懂，多讀幾遍

所以我們的演算法就是，

遇到0，1，2把i,j,k後面1位的值賦成對應的值即可。

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int i = -1,j = -1,k = -1;//注意i，j，k的含義
        int m;
        for(m = 0; m < nums.size();m++){
            if(nums[m] == 0){
                nums[++k] = 2;
                nums[++j] = 1;
                nums[++i] = 0;
            }
            else if(nums[m] == 1){
                nums[++k] = 2;
                nums[++j] = 1;
            }
            else {
                nums[++k] = 2;
            }
        }
    }
};

總結：

學習了三向切分的2種實現形式，

一種是常規的設定各區間邊界的解法：

1.先設定第一個區間的末尾邊界，再設定第三個區間的開頭邊界。

2.遇到第一區間的元素(0)，與第一區間末尾邊界交換，末尾邊界+1；遇到第2區間的元素，跳過；遇到第三區間的元素，與第三區間開頭邊界交換，並加1。

一種是設定三個指標的三向切分：

i指向第一小元素的最後一個index,j指向第2小元素的最後一個index, k指向第三小元素的最後一個index。

遇到第一小的元素，把i,j,k都往後推一步，並且在賦值。

遇到第2小的元素，由於只會影響2，3區間，於是只用把，j,k往後推一步再賦值。

遇到第3小的元素，只會影響3區間，把k往後推一步賦值。

1區間指第一個區間，也就是最小的區間。

今天總結乾貨很多，但同時也發現了自己的基礎不牢，因為三向切分在《演算法》4中講過，忘乾淨了。。