LeetCode 分类颜色

LeetCode   分类颜色

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

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

进阶：

• 一个直观的解决方案是使用计数排序的两趟扫描算法。
  首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
• 你能想出一个仅使用常数空间的一趟扫描算法吗？

1.   使用基数排序：

class Solution:
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        #桶排序
        count = []
        for i in [0,1,2]:
            count.append(nums.count(i))
        j=0
        for i in [0,1,2]:
            while count[i]>0:
                nums[j] = i
                j += 1
                count[i] -= 1
        print(nums)

2.    使用快排：

两路快排的Partition的实现（c++）：

// v为pivot，初始存储在arr[l]的位置 
int j = l; // 循环过程保持 arr[l+1...j] < v ; arr[j+1...i) > v 
for( int i = l + 1 ; i <= r ; i ++ )
    if( arr[i] < v ) 
        swap( arr[++j] , arr[i] );
swap( arr[l] , arr[j]); // 此时，j指向pivot的正确位置

class Solution:
    def _sortColors(self, nums, l, r):
        if l >= r:
            return
        # pratition
        j = l+1
        pivot = nums[l]
        for i in range(l+1, r+1):
            if nums[i] < pivot:
                nums[i], nums[j] = nums[j], nums[i]
                j += 1
        j -= 1
        nums[l], nums[j] = nums[j], nums[l]

        #devide
        self._sortColors(nums, l, j-1)
        self._sortColors(nums, j+1, r)
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        self._sortColors(nums, 0, len(nums)-1)

    这样的一个快排，在面临有序或者近乎有序的数组时，会退化成为一个O(n^2)的算法。于是我们使用了一个很简单的随机选取pivot的方式来处理这个问题。这步随机化让快速排序的时间期望成为了O(nlogn)，并且只有极低的概率退化为O(n^2)。
    面对有大量重复元素的数据时，还是有可能退化成O(n^2)级别的。通过这个思路，我们可以进一步优化，提出三路快排的思想。

3.   三路快排

三路快排的Partition代码是这样的。

// v为pivot，初始存储在arr[l]的位置 
int lt = l; // 循环过程中保持 arr[l+1...lt] < v 
int gt = r + 1; // 循环过程中保持 arr[gt...r] > v 
int i = l+1; // 循环过程中保持 arr[lt+1...i) == v 
while( i < gt ){
    if( arr[i] < v ){ 
        swap( arr[i++], arr[lt+1]); lt ++; } 
    else if( arr[i] > v ){ 
        swap( arr[i], arr[gt-1]); gt --; } 
    else // arr[i] == v 
        i ++; 
    } 
swap( arr[l] , arr[lt] ); 
// 此时 arr[lt...gt-1]部分为数组中元素等于v的部分 
// 之后只需要递归地对arr[l...lt-1]和arr[gt...r]两部分进行三路快排即可

class Solution:
    def _sortColors(self, nums, l, r):
        if l >= r:
            return
        # pratition
        pivot = nums[l]
        j = l+1  #循环过程中保持 arr[lt+1...j) == v
        lt = l #循环过程中保持 arr[l+1...lt] < v
        gt = r # 循环过程中保持 arr[gt...r] > v
        while j <= gt:
            if nums[j] < pivot:
                nums[lt], nums[j] = nums[j], nums[lt]
                j += 1
                lt += 1
            elif nums[j] > pivot:
                nums[gt], nums[j] = nums[j], nums[gt]
                gt -= 1
            else:
                j += 1

        #devide
        self._sortColors(nums, l, lt-1)
        self._sortColors(nums, gt+1, r)
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        self._sortColors(nums, 0, len(nums)-1)