75. 颜色分类

#双指针，p0，p1
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def swap(i,j):
            print(i,j)
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp
        n = len(nums)
        p0, p1 = 0, 0
        for i in range(n):
            if nums[i] == 0:
                swap(p0, i)
                if p0 < p1:
                    swap(i, p1)
                #这两个在if:p0<p1之外
                #这两个共同+1，是因为，p0要指向下一个将要填入0的位置，
                #0<1所以p1不会在当前位置填入，所以要+1
                #p1只可能大于或等于p0，不可能小于p0
                p0 += 1
                p1 += 1
            #elif的使用
            elif nums[i] == 1:
                swap(p1, i)
                p1 += 1

#两次遍历
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def swap(i,j):
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp

        n = len(nums)
        l = 0
        for i in range(n):
            if nums[i] == 0:
                swap(i,l)
                l += 1
        for j in range(l,n):
            if nums[j] == 1:
                swap(l,j)
                l += 1
        return nums

#官方题解：p0,p2
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def swap(i,j):
            print(i,j)
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp
        n = len(nums)
        p0, p2 = 0, n-1
        i = 0
        #如果没有被i<=p2这个条件的话，
        #当i>p2时，i指向的一直都是2，会一直交换位置，把之前交换好的打乱
        #p2后面全是2，遍历到p2时，就不用遍历了
        while i <= p2:
            while i <= p2 and nums[i] == 2:
                swap(p2, i)
                p2 -= 1
                #因为在这个内层while循环中，p2的值会变，所以内层的while要加上i <= p2，这个条件
            if nums[i] == 0:
                swap(p0, i)
                p0 += 1
            i += 1
        return nums


                    

#倒序遍历
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def swap(i,j):
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp
        n = len(nums)
        p1, p2 = n-1, n-1
        for i in range(n-1, -1, -1):
            if nums[i] == 2:
                swap(i, p2)
                #如果p1<p2时，遇到nums[i]==2，那么交换的p2的位置本来为排好的1，与i交换之后被打乱
                #所以，i和p1要再交换一下，把1交换回来
                if p1 < p2:
                    swap(i, p1)
                p2-=1
                p1-=1
            elif nums[i] == 1:
                swap(i, p1)
                p1 -= 1

        return nums

class Solution {
    public void sortColors(int[] nums) {
        int l = 0;//0的右边界，[0,l-1]都为0
        int r = nums.length-1; // [r,n-1]为2
        int idx=0;
        while(idx<=r){//小于等于是因为，r和idx换完之后，r可能和idx相等，但idx此时的值还未判断
            if(nums[idx]==0){
                swap(nums,idx,l);
                idx++;
                l++;
            }else if(nums[idx]==1){
                idx++;
            }else{
                swap(nums,idx,r);
                r--;
            }
        }

    }
    public void swap(int[] nums,int i,int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    
}

class Solution {
    public void sortColors(int[] nums) {
        if(nums.length < 0){
            return;
        }
        for(int i=0;i<nums.length;i++){
            for(int j=i-1;j>=0 && nums[j]>nums[j+1];j--){
                swap(nums,j,j+1);
            }
        }

    }
    public void swap(int[] nums,int i,int j){
        nums[i] = nums[i] ^ nums[j];
        nums[j] = nums[i] ^ nums[j];
        nums[i] = nums[i] ^ nums[j];
    }
}