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 + ; // 循环过程中保持 arr[gt...r] > v
 int i = l+; // 循环过程中保持 arr[lt+1...i) == v
 while( i < gt ){
     if( arr[i] < v ){
         swap( arr[i++], arr[lt+]); lt ++; }
     else if( arr[i] > v ){
         swap( arr[i], arr[gt-]); 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)