devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

十大经典排序算法详解及优化_排序算法 csdn

作者：我家自动化 | 2024-08-16 14:26:00

赞

踩

排序算法 csdn

算法概述

0.1 算法分类

十种常见排序算法可以分为两大类：

非线性时间比较类排序：

通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。

包括：交换排序（冒泡、快速排序）插入排序（简单插入排序、希尔排序）选择排序（简单选择排序、堆排序）归并排序（二路，多路）

线性时间非比较类排序：

不通过比较来决定元素间的相对次序，可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 

包括：基数排序、桶排序

0.2 算法复杂度

0.3 相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。 

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 

1.1 算法描述

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

1.2 动图演示

1.3 代码实现

（1）优化1（优化外层循环）：

    　若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个标签flag，在每趟排序开始前，先将其置为0。若排序过程中发生了交换，则将其置为1。各趟排序结束时检查flag，若未曾发生过交换则终止算法，不再进行下一趟排序。

（2）优化2（优化内层循环）

       记住最后一次交换发生位置lastExchange的冒泡排序。在每趟扫描中，记住最后一次交换发生的位置lastExchange，（该位置之后的相邻记录均已有序）。下一趟排序开始时，R[1..lastExchange-1]是无序区，R[lastExchange..n]是有序区。这样，一趟排序可能使当前无序区扩充多个记录，因此记住最后一次交换发生的位置lastExchange，从而减少排序的趟数。

  1. #include<iostream>  
  2. using namespace std;  
  3. #include<cassert>  
  4.   
  5. //冒泡排序  
  6. void BubbleSort1(int* arr, size_t size)  
  7. {  
  8.     assert(arr);  
  9.     int i = 0, j = 0;  
  10.     for (i = 0; i < size - 1; i++)//一共要排序size-1次  
  11.     {  
  12.         for (j = 0; j < size - 1 - i; j++)//选出该趟排序的最大值往后移动  
  13.         {  
  14.             if (arr[j] > arr[j + 1])  
  15.             {  
  16.                 int tmp = arr[j];  
  17.                 arr[j] = arr[j + 1];  
  18.                 arr[j + 1] = tmp;  
  19.             }  
  20.         }  
  21.     }  
  22. }  
  23.   
  24. //冒泡排序优化1  
  25. void BubbleSort2(int* arr, size_t size)  
  26. {  
  27.     assert(arr);  
  28.     int i = 0, j = 0;  
  29.     for (i = 0; i < size - 1; i++)//一共要排序size-1次  
  30.     {  
  31.         //每次遍历标志位都要先置为0，才能判断后面的元素是否发生了交换  
  32.         int flag = 0;  
  33.         for (j = 0; j < size - 1 - i; j++)//选出该趟排序的最大值往后移动  
  34.         {  
  35.             if (arr[j] > arr[j + 1])  
  36.             {  
  37.                 int tmp = arr[j];  
  38.                 arr[j] = arr[j + 1];  
  39.                 arr[j + 1] = tmp;  
  40.                 flag = 1;//只要有发生了交换，flag就置为1  
  41.             }  
  42.         }  
  43.         //判断标志位是否为0，如果为0，说明后面的元素已经有序，就直接return  
  44.         if (flag == 0)  
  45.         {  
  46.             return;  
  47.         }  
  48.     }  
  49. }  
  50.   
  51. //冒泡排序优化2  
  52. void BubbleSort3(int* arr, size_t size)  
  53. {  
  54.     assert(arr);  
  55.     int i = 0, j = 0;  
  56.     int k = size - 1,pos = 0;   //pos变量用来标记循环里最后一次交换的位置       
  57.     for (i = 0; i < size - 1; i++)  //一共要排序size-1次  
  58.     {  
  59.         //每次遍历标志位都要先置为0，才能判断后面的元素是否发生了交换  
  60.         int flag = 0;  
  61.         for (j = 0; j < k; j++)//选出该趟排序的最大值往后移动  
  62.         {  
  63.             if (arr[j] > arr[j + 1])  
  64.             {  
  65.                 int tmp = arr[j];  
  66.                 arr[j] = arr[j + 1];  
  67.                 arr[j + 1] = tmp;  
  68.                 flag = 1;   //只要有发生了交换，flag就置为1  
  69.                 pos = j;    //循环里最后一次交换的位置 j 赋给pos  
  70.             }  
  71.         }  
  72.         k = pos;  
  73.         //判断标志位是否为0，如果为0，说明后面的元素已经有序，就直接return  
  74.         if (flag == 0)  
  75.         {  
  76.             return;  
  77.         }  
  78.     } 
  79. }  
  80.   
  81. int main()  
  82. {  
  83.     int arr[5] = { 5,4,3,2,1 };  
  84.     cout << "初始顺序为：";  
  85.     for (int i = 0; i < 5; i++)  
  86.     {  
  87.         cout << arr[i] << " ";  
  88.     }  
  89.     cout << endl;  
  90.     /*BubbleSort1(arr, 5);*/  
  91.     /*BubbleSort2(arr, 5);*/  
  92.     BubbleSort3(arr, 5);  
  93.     cout << "冒泡排序后顺序为：";  
  94.     for (int i = 0; i < 5; i++)  
  95.     {  
  96.         cout << arr[i] << " ";  
  97.     }  
  98.     cout << endl;  
  99.     system("pause");  
  100.     return 0;  
  101. }

2、选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

  • 初始状态：无序区为R[1..n]，有序区为空；
  • 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
  • n-1趟结束，数组有序化了。

2.2 动图演示

　　

2.3 代码实现

（1）优化

在每一次查找最小值的时候，也可以找到一个最大值，然后将两者分别放在它们应该出现的位置，这样遍历的次数就比较少了。代码中，第一次交换结束后，如果left那个位置原本放置的就是最大数，交换之后，需要将最大数的下标还原。 需要注意的是，每次记住的最小值或者最大值的下标，这样方便进行交换。

  1. //选择排序
  2. void SelectSort(vector<int>& v)
  3. {
  4.     for(int i = 0; i < v.size() - 2; ++i)
  5.     {
  6.         int k = i;
  7.         for(int j = i + 1; j < v.size() - 1; ++j)
  8.         {
  9.             //找到最小的数的下标
  10.             if(v[j] < v[k])
  11.                 k = j;
  12.         }
  13.         if(k != i)
  14.         {
  15.             swap(v[k],v[i]);
  16.         }
  17.     }
  18. }
  19. //优化
  20. void SelectSort(vector<int>& a)
  21. {
  22.     int left = 0;
  23.     int right = a.size() - 1;
  24.     int min = left;//存储最小值的下标
  25.     int max = left;//存储最大值的下标
  26.     while(left <= right)
  27.     {
  28.         min = left;
  29.         max = left;
  30.         for(int i = left; i <= right; ++i)
  31.         {
  32.             if(a[i] < a[min])
  33.             {
  34.                 min = i;
  35.             }
  36.             if(a[i] > a[max])
  37.             {
  38.                 max = i;
  39.             }
  40.         }
  41.         swap(a[left],a[min]);
  42.         if(left == max)
  43.             max = min;
  44.         swap(a[right],a[max]);
  45.  
  46.         ++left;
  47.         --right;
  48.     }
  49. }

2.4 算法分析

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。

3.2 动图演示

3.2 代码实现

（1）优化1

改写，将搜索和数据后移这二个步骤合并。即每次a[i]先和前面一个数据a[i-1]比较，如果a[i] > a[i-1]说明a[0…i]也是有序的，无须调整。否则就令j=i-1,temp=a[i]。然后一边将数据a[j]向后移动一边向前搜索，当有数据a[j]<a[i]时停止并将temp放到a[j + 1]处。

（2）优化2

再对将a[j]插入到前面a[0…j-1]的有序区间所用的方法进行改写，用数据交换代替数据后移。如果a[j]前一个数据a[j-1] > a[j]，就交换a[j]和a[j-1]，再j--直到a[j-1] <= a[j]。这样也可以实现将一个新数据新并入到有序区间。

  1. //插入排序
  2. void Insertsort1(int a[], int n)  
  3. {  
  4.     int i, j, k;  
  5.     for (i = 1; i < n; i++)  
  6.     {  
  7.         //为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置  
  8.         for (j = i - 1; j >= 0; j--)  
  9.             if (a[j] < a[i])  
  10.                 break; 
  11.         //如找到了一个合适的位置  
  12.         if (j != i - 1)  
  13.         {  
  14.             //将比a[i]大的数据向后移  
  15.             int temp = a[i];  
  16.             for (k = i - 1; k > j; k--)  
  17.                 a[k + 1] = a[k];  
  18.             //将a[i]放到正确位置上  
  19.             a[k + 1] = temp;  
  20.         }  
  21.     }  
  22. }  
  23. //优化1
  24. void Insertsort2(int a[], int n)  
  25. {  
  26.     int i, j;  
  27.     for (i = 1; i < n; i++)  
  28.         if (a[i] < a[i - 1])  
  29.         {  
  30.             int temp = a[i];  
  31.             for (j = i - 1; j >= 0 && a[j] > temp; j--)  
  32.                 a[j + 1] = a[j];  
  33.             a[j + 1] = temp;  
  34.         }  
  35. }  
  36. //优化2
  37. void Insertsort3(int a[], int n)  
  38. {  
  39.     int i, j;  
  40.     for (i = 1; i < n; i++)  
  41.         for (j = i - 1; j >= 0 && a[j] > a[j + 1]; j--)  
  42.             Swap(a[j], a[j + 1]);  
  43. }

3.4 算法分析

插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

4、希尔排序（Shell Sort）

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

4.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

  • 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  • 按增量序列个数k，对序列进行k 趟排序；
  • 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 动图演示

4.3 代码实现

（1）优化1

shellsort1代码虽然对直观的理解希尔排序有帮助，但代码量太大了，不够简洁清晰。因此进行下改进和优化，以第二次排序为例，原来是每次从1A到1E，从2A到2E，可以改成从1B开始，先和1A比较，然后取2B与2A比较，再取1C与前面自己组内的数据比较…….。这种每次从数组第gap个元素开始，每个元素与自己组内的数据进行直接插入排序显然也是正确的。

（2）优化2

将直接插入排序部分用直接插入排序的第三种方法来改

  1. //希尔排序
  2. void shellsort1(int a[], int n)  
  3. {  
  4.     int i, j, gap;  
  5.   
  6.     for (gap = n / 2; gap > 0; gap /= 2) //步长  
  7.         for (i = 0; i < gap; i++)        //直接插入排序  
  8.         {  
  9.             for (j = i + gap; j < n; j += gap)   
  10.                 if (a[j] < a[j - gap])  
  11.                 {  
  12.                     int temp = a[j];  
  13.                     int k = j - gap;  
  14.                     while (k >= 0 && a[k] > temp)  
  15.                     {  
  16.                         a[k + gap] = a[k];  
  17.                         k -= gap;  
  18.                     }  
  19.                     a[k + gap] = temp;  
  20.                 }  
  21.         }  
  22. }  
  23. //优化1
  24. void shellsort2(int a[], int n)  
  25. {  
  26.     int j, gap;  
  27.       
  28.     for (gap = n / 2; gap > 0; gap /= 2)  
  29.         for (j = gap; j < n; j++)//从数组第gap个元素开始  
  30.             if (a[j] < a[j - gap])//每个元素与自己组内的数据进行直接插入排序  
  31.             {  
  32.                 int temp = a[j];  
  33.                 int k = j - gap;  
  34.                 while (k >= 0 && a[k] > temp)  
  35.                 {  
  36.                     a[k + gap] = a[k];  
  37.                     k -= gap;  
  38.                 }  
  39.                 a[k + gap] = temp;  
  40.             }  
  41. }  
  42. //优化2
  43. void shellsort3(int a[], int n)  
  44. {  
  45.     int i, j, gap;  
  46.   
  47.     for (gap = n / 2; gap > 0; gap /= 2)  
  48.         for (i = gap; i < n; i++)  
  49.             for (j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)  
  50.                 Swap(a[j], a[j + gap]);  
  51. }

4.4 算法分析

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

5、归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。 

5.1 算法描述

  • 把长度为n的输入序列分成两个长度为n/2的子序列；
  • 对这两个子序列分别采用归并排序；
  • 将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

5.3 代码实现

  1. void mergeArray(int arr[], int first, int mid, int last, int temp[])
  2. {
  3. 	int i = first;   //第一个序列开始位置
  4. 	int j = mid + 1; //第二个序列开始位置
  5. 	int m = mid;     //第一个序列结束位置
  6. 	int n = last;    //第二个序列结束位置
  7. 	int k = 0;       //temp下标
  8. 	while (i <= m && j <= n)  //序列一二是否放完
  9. 	{
  10. 		if (arr[i] < arr[j])  //k一直++，i,j任意时刻只有一个++
  11. 			temp[k++] = arr[i++];
  12. 		else
  13. 			temp[k++] = arr[j++];
  14. 	}
  15. 	while (i <= m)  //序列一是否放完
  16. 	{
  17. 		temp[k++] = arr[i++];
  18. 	}
  19. 	while (i <= m && j <= n)  //序列一二是否放完
  20. 	{
  21. 		temp[k++] = arr[j++];
  22. 	}
  23. 	//合并成一个有序序列
  24. 	for (i = 0; i < k; i++)
  25. 	{
  26. 		arr[first + i] = temp[i];
  27. 	}
  28. }
  29. void merge(int arr[], int first, int mid, int last, int temp[])
  30. {
  31. 	int mid;
  32. 	if (first >= last)
  33. 		return;
  34. 	mid = (first + last) / 2;
  35. 	merge(arr,first,mid,temp);
  36. 	merge(arr, mid+1, last, temp);
  37. 	mergeArray(arr, first, mid,last,temp);
  38. }
  39. void mergeSort(int arr[], int num)
  40. {
  41. 	int *temp = (int *)malloc(sizeof(arr[0])*num);
  42. 	if (temp == NULL)
  43. 		return;
  44. 	merge(arr, 0, num - 1, temp);
  45. }

5.4 算法分析

归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。

6、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

  • 从数列中挑出一个元素，称为 “基准”（pivot）；
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 动图演示

6.3 代码实现

  1. int QKPass(int r[], int left, int right)
  2. {
  3. 	int low = left;
  4. 	int high = right;
  5. 	r[0] = r[left];
  6. 	while (low < high)
  7. 	{
  8. 		while (low < high && r[high] > r[0])
  9. 		{
  10. 			high--;
  11. 		}
  12. 		if (low < high)
  13. 		{
  14. 			r[low] = r[high];
  15. 			low++;
  16. 		}
  17. 		while (low < high && r[low] < r[0])
  18. 		{
  19. 			low++;
  20. 		}
  21. 		if (low < high)
  22. 		{
  23. 			r[high] = r[low];
  24. 			high--;
  25. 		}
  26. 	}
  27. 	r[low] = r[0];
  28. 	return low;
  29. }
  30. void QKSort(int r[], int low,int high)
  31. {
  32. 	if (low < high)
  33. 	{
  34. 		int pos = QKPass(r,low,high);
  35. 		QKSort(r, low, pos - 1);
  36. 		QKSort(r, pos + 1, high);
  37. 	}
  38. }

优化1：三平均分区法

选用待排数组最左边、最右边和最中间的三个元素的中间值作为中轴。通过比较选出其中的中值。取这3个值的好处是在实际问题中，出现近似顺序数据或逆序数据的概率较大，此时中间数据必然成为中值，而也是事实上的近似中值。万一遇到正好中间大两边小（或反之）的数据，取的值都接近最值，那么由于至少能将两部分分开，实际效率也会有2倍左右的增加，而且利于将数据略微打乱，破坏退化的结构。

数据集较小时，不必继续递归调用快速排序算法，而改为调用其他的对于小规模数据集处理能力较强的排序算法来完成。Introsort就是这样的一种算法，它开始采用快速排序算法进行排序，当递归达到一定深度时就改为堆排序来处理。克服了快速排序在小规模数据集处理中复杂的中轴选择，也确保了堆排序在最坏情况下O(n log n)的复杂度。

  1. //introsort 算法实现
  2. //数据量的分界线，决定了使用quick sort/heap sort还是insertion sort
  3. const int threshold=16;
  4.  
  5. //堆排序用到的辅助函数
  6. int parent(int i)
  7. {
  8.     return (int)((i-1)/2);
  9. }
  10.  
  11. int left(int i)
  12. {
  13.     return 2 * i+1;
  14. }
  15.  
  16. int right(int i)
  17. {
  18.     return (2 * i + 2);
  19. }
  20.  
  21. void heapShiftDown(int heap[], int i, int begin,int end)
  22. {
  23.     int l = left(i-begin)+begin;
  24.     int r = right(i-begin)+begin;
  25.     int largest=i;
  26. 	//找出左右字节点与父节点中的最大者
  27.     if(l < end && heap[l] > heap[largest])
  28.         largest = l;
  29.     if(r < end && heap[r] > heap[largest])
  30.         largest = r;
  31. 	//若最大者不为父节点，则需交换数据，并持续向下滚动至满足最大堆特性
  32.     if(largest != i)
  33.     {
  34. 		swap(heap[largest],heap[i]);
  35.         heapShiftDown(heap, largest, begin,end);
  36.     }
  37. }
  38.  //自底向上的开始建堆，即从堆的倒数第二层开始
  39. void buildHeap(int heap[],int begin,int end)
  40. {
  41.     for(int i = (begin+end)/2; i >= begin; i--)
  42.     {
  43.         heapShiftDown(heap, i, begin,end);
  44.     }
  45. }
  46.  
  47.  //堆排序
  48. void heapSort(int heap[], int begin,int end)
  49. {
  50.     buildHeap(heap,begin,end);
  51.     for(int i = end; i >begin; i--)
  52.     {
  53. 		swap(heap[begin],heap[i]);
  54.         heapShiftDown(heap,begin,begin, i);
  55.     }
  56. }
  57.  
  58.  
  59. //插入排序
  60. void insertionSort(int array[],int len)
  61. {
  62.     int i,j,temp;
  63.     for(i=1;i<len;i++)
  64.     {
  65.       temp = array[i];//store the original sorted array in temp
  66.       for(j=i;j>0 && temp < array[j-1];j--)//compare the new array with temp(maybe -1?)
  67.       {
  68.           array[j]=array[j-1];//all larger elements are moved one pot to the right
  69.       }
  70.       array[j]=temp;
  71.     }
  72. }
  73.  
  74.  
  75. //三点中值
  76. int median3(int array[],int first,int median,int end)
  77. {
  78. 		if(array[first]<array[median])
  79. 		{
  80. 				if(array[median]<array[end])
  81. 						return median;
  82. 				else if(array[first]<array[end])
  83. 						return end;
  84. 				else
  85. 						return first;
  86. 		}
  87. 		else if(array[first]<array[end])
  88. 				return first;
  89. 		else if(array[median]<array[end])
  90. 				return end;
  91. 		else 
  92. 				return median;
  93. }
  94.  
  95. //对数组分割
  96. int partition(int array[],int left,int right,int p)
  97. {
  98. 		//选择最右侧的元素作为分割标准
  99. 		int index = left;
  100. 		swap(array[p],array[right]);
  101. 		int pivot = array[right]; 
  102. 	    //将所有小于标准的点移动到index的左侧	
  103.         for (int i=left; i<right; i++)
  104.         {
  105.                 if (array[i] < pivot)    
  106.                         swap(array[index++],array[i]);
  107.         }
  108. 		//将标准与index指向的元素交换，返回index，即分割位置
  109.         swap(array[right],array[index]);
  110.         return index;
  111. }
  112.  
  113. //递归的对数组进行分割排序
  114. void introSortLoop(int array[],int begin,int end,int depthLimit)
  115. {
  116. 		while((end-begin+1)>threshold) //子数组数据量大小，则交给后面的插入排序进行处理
  117. 		{
  118. 				if(depthLimit==0)      //递归深度过大，则由堆排序代替
  119. 				{
  120. 						heapSort(array,begin,end);
  121. 						return ;
  122. 				}
  123. 				--depthLimit;
  124. 				//使用quick sort进行排序
  125. 				int cut=partition(array,begin,end,
  126. 								median3(array,begin,begin+(end-begin)/2,end)); 
  127. 				introSortLoop(array,cut,end,depthLimit);
  128. 				end=cut;    //对左半段进行递归的sort
  129. 		}
  130. }
  131.  
  132. //计算最大容忍的递归深度
  133. int lg(int n)
  134. {
  135. 		int k;
  136. 		for(k=0;n>1;n>>=1) ++k;
  137. 		return k;
  138. }
  139.  
  140.  
  141. //霸气的introsort
  142. void introSort(int array[],int len)
  143. {
  144. 		if(len!=1)
  145. 		{
  146. 				introSortLoop(array,0,len-1,lg(len)*2);
  147. 				insertionSort(array,len);
  148. 		}
  149. }

优化2：当分区的规模达到一定小时，便停止快速排序算法。即快速排序算法的最终产物是一个“几乎”排序完成的有序数列。数列中有部分元素并没有排到最终的有序序列的位置上，但是这种元素并不多。可以对这种“几乎”完成排序的数列使用插入排序算法进行排序以最终完成整个排序过程。因为插入排序对于这种“几乎”完成的排序数列有着接近线性的复杂度。这一改进被证明比持续使用快速排序算法要有效的多。

优化3：在递归排序子分区的时候，总是选择优先排序那个最小的分区。这个选择能够更加有效的利用存储空间从而从整体上加速算法的执行。

对于快速排序算法来说，实际上大量的时间都消耗在了分区上面，尤其是当要分区的所有的元素值都相等时，一般的快速排序算法就陷入了最坏的一种情况，也即反复的交换相同的元素并返回最差的中轴值。对于这种情况的一种改进办法就是将分区分为三块而不是原来的两块：一块是小于中轴值的所有元素，一块是等于中轴值的所有元素，另一块是大于中轴值的所有元素。另一种简单的改进方法是，当分区完成后，如果发现最左和最右两个元素值相等的话就避免递归调用而采用其他的排序算法来完成。

7、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7.1 算法描述

  • 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
  • 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
  • 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

7.2 动图演示

7.3 代码实现

  1. //堆排序
  2. void HeapSort(int arr[],int len){
  3.     int i;
  4.     //初始化堆，从最后一个父节点开始
  5.     for(i = len/2 - 1; i >= 0; --i){
  6.         Heapify(arr,i,len);
  7.     }
  8.     //从堆中的取出最大的元素再调整堆
  9.     for(i = len - 1;i > 0;--i){
  10.         int temp = arr[i];
  11.         arr[i] = arr[0];
  12.         arr[0] = temp;
  13.         //调整成堆
  14.         Heapify(arr,0,i);
  15.     }
  16. }
  17. 再看 调整成堆的函数
  18.  
  19. void Heapify(int arr[], int first, int end){
  20.     int father = first;
  21.     int son = father * 2 + 1;
  22.     while(son < end){
  23.         if(son + 1 < end && arr[son] < arr[son+1]) ++son;
  24.         //如果父节点大于子节点则表示调整完毕
  25.         if(arr[father] > arr[son]) break;
  26.         else {
  27.          //不然就交换父节点和子节点的元素
  28.             int temp = arr[father];
  29.             arr[father] = arr[son];
  30.             arr[son] = temp;
  31.             //父和子节点变成下一个要比较的位置
  32.             father = son;
  33.             son = 2 * father + 1;
  34.         }
  35.     }
  36. }
  1. var len;   // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
  2.  
  3. function buildMaxHeap(arr) {  // 建立大顶堆
  4.     len = arr.length;
  5.     for (var i = Math.floor(len/2); i >= 0; i--) {
  6.         heapify(arr, i);
  7.     }
  8. }
  9.  
  10. function heapify(arr, i) {    // 堆调整
  11.     var left = 2 * i + 1,
  12.         right = 2 * i + 2,
  13.         largest = i;
  14.  
  15.     if (left < len && arr[left] > arr[largest]) {
  16.         largest = left;
  17.     }
  18.  
  19.     if (right < len && arr[right] > arr[largest]) {
  20.         largest = right;
  21.     }
  22.  
  23.     if (largest != i) {
  24.         swap(arr, i, largest);
  25.         heapify(arr, largest);
  26.     }
  27. }
  28.  
  29. function swap(arr, i, j) {
  30.     var temp = arr[i];
  31.     arr[i] = arr[j];
  32.     arr[j] = temp;
  33. }
  34.  
  35. function heapSort(arr) {
  36.     buildMaxHeap(arr);
  37.  
  38.     for (var i = arr.length - 1; i > 0; i--) {
  39.         swap(arr, 0, i);
  40.         len--;
  41.         heapify(arr, 0);
  42.     }
  43.     return arr;
  44. }

8、计数排序（Counting Sort）

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

8.1 算法描述

  • 找出待排序的数组中最大和最小的元素；
  • 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  • 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  • 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 动图演示

8.3 代码实现

  1. function countingSort(arr, maxValue) {
  2.     var bucket =new Array(maxValue + 1),
  3.         sortedIndex = 0;
  4.         arrLen = arr.length,
  5.         bucketLen = maxValue + 1;
  6.  
  7.     for (var i = 0; i < arrLen; i++) {
  8.         if (!bucket[arr[i]]) {
  9.             bucket[arr[i]] = 0;
  10.         }
  11.         bucket[arr[i]]++;
  12.     }
  13.  
  14.     for (var j = 0; j < bucketLen; j++) {
  15.         while(bucket[j] > 0) {
  16.             arr[sortedIndex++] = j;
  17.             bucket[j]--;
  18.         }
  19.     }
  20.  
  21.     return arr;
  22. }

8.4 算法分析

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

9.1 算法描述

  • 设置一个定量的数组当作空桶；
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • 对每个不是空的桶进行排序；
  • 从不是空的桶里把排好序的数据拼接起来。 

9.2 图片演示

9.3 代码实现

  1. function bucketSort(arr, bucketSize) {
  2.     if (arr.length === 0) {
  3.       return arr;
  4.     }
  5.  
  6.     var i;
  7.     var minValue = arr[0];
  8.     var maxValue = arr[0];
  9.     for (i = 1; i < arr.length; i++) {
  10.       if (arr[i] < minValue) {
  11.           minValue = arr[i];               // 输入数据的最小值
  12.       }else if (arr[i] > maxValue) {
  13.           maxValue = arr[i];               // 输入数据的最大值
  14.       }
  15.     }
  16.  
  17.     // 桶的初始化
  18.     var DEFAULT_BUCKET_SIZE = 5;           // 设置桶的默认数量为5
  19.     bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
  20.     var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;  
  21.     var buckets =new Array(bucketCount);
  22.     for (i = 0; i < buckets.length; i++) {
  23.         buckets[i] = [];
  24.     }
  25.  
  26.     // 利用映射函数将数据分配到各个桶中
  27.     for (i = 0; i < arr.length; i++) {
  28.         buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
  29.     }
  30.  
  31.     arr.length = 0;
  32.     for (i = 0; i < buckets.length; i++) {
  33.         insertionSort(buckets[i]);                     // 对每个桶进行排序，这里使用了插入排序
  34.         for (var j = 0; j < buckets[i].length; j++) {
  35.             arr.push(buckets[i][j]);                     
  36.         }
  37.     }
  38.  
  39.     return arr;
  40. }

9.4 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。 

10、基数排序（Radix Sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

10.1 算法描述

  • 取得数组中的最大数，并取得位数；
  • arr为原始数组，从最低位开始取每个位组成radix数组；
  • 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

10.2 动图演示

10.3 代码实现

  1. // LSD Radix Sort
  2. var counter = [];
  3. function radixSort(arr, maxDigit) {
  4.     var mod = 10;
  5.     var dev = 1;
  6.     for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
  7.         for(var j = 0; j < arr.length; j++) {
  8.             var bucket = parseInt((arr[j] % mod) / dev);
  9.             if(counter[bucket]==null) {
  10.                 counter[bucket] = [];
  11.             }
  12.             counter[bucket].push(arr[j]);
  13.         }
  14.         var pos = 0;
  15.         for(var j = 0; j < counter.length; j++) {
  16.             var value =null;
  17.             if(counter[j]!=null) {
  18.                 while ((value = counter[j].shift()) !=null) {
  19.                       arr[pos++] = value;
  20.                 }
  21.           }
  22.         }
  23.     }
  24.     return arr;
  25. }

10.4 算法分析

基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。

基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/988720
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号