Sort —— 排序
插入排序:直接插入排序、希尔排序
选择排序:选择排序、堆排序
交换排序:冒泡排序、快速排序
归并排序:归并排序
直接插入排序
直接插入排序的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,将它插入到有序表中的适当位置,使之成为新的有序表,重复n-1次可完成排序过程。
代码实现:
void InsertSort(int *a, size_t n) { for (int i = 0; i < n - 1 ; i++) { int end = i; int tmp = a[end + 1]; while (end >=0) { if (a[end] > tmp) { a[end + 1] = a[end]; --end; } else { break; } } a[end + 1] = tmp; } }
直接插入排序的时间复杂度和稳定性
直接插入排序的时间复杂度是O(N2):假设被排序的数列中有N个数,遍历一趟时间复杂度是O(N),需遍历多少次呢?N-1次,因此,其时间复杂度是O(N2)。
直接插入排序是稳定的算法,它满足稳定算法的定义:假设在数列中存在a[i]=a[j],若在排序之前,a[i]在a[j]前面;并且排序之后,a[i]仍然在a[j]前面。则这个排序算法是稳定的!
希尔排序
希尔排序是以它的发明者Donald Shell名字命名的,希尔排序是插入排序的改进版,实现简单,对于中等规模数据的性能表现还不错。
首先它把较大的数据集合分割成若干个小组(逻辑上分组),然后对每一个小组分别进行插入排序,此时,插入排序所作用的数据量比较小(每一个小组),插入的效率比较高。
代码实现:
void ShellSort(int *a, size_t n) { int gap = n; while (gap > 1) { gap = gap / 3 + 1; for (int i = 0; i < n - gap; i++) { int end = i; int tmp = a[end + gap]; while (end >= 0 && a[end] > tmp) { a[end + gap] = a[end]; end -= gap; } a[end + gap] = tmp; } } }
希尔排序的时间复杂度和稳定性
希尔排序的复杂度和gap是相关的
希尔排序不是稳定的,虽然插入排序是稳定的,但是希尔排序在插入的时候是
跳跃性插入
的,有可能破坏稳定性.
选择排序
选择排序是一种简单直观的排序算法。其基本思想是:首先在未排序的数列中找到最小(or最大)元素,然后将其存放到数列的起始位置;
接着,再从剩余未排序的元素中继续寻找最小(or最大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕
。
代码实现:
代码实现:
void SelectSort(int *a, int n) { int min, temp; for (int i = 0; i < n - 1; i++) { min = i; for (int j = i + 1; j < n; j++) { if (a[j] < a[min]) { min = j; } } if (min != i) { temp = a[min]; a[min] = a[i]; a[i] = temp; } } }
选择排序的时间复杂度和稳定性
选择排序的时间复杂度是
O(N
2
)
:
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N),需要遍历多少次呢?N-1次因此,选择排序的时间复杂度是O(N
2
)。
选择排序是稳定的算法,它满足稳定算法的定义:假设在数列中存在a[i]=a[j],若在排序之前,a[i]在a[j]前面;并且排序之后,a[i]仍然在a[j]前面。则这个排序算法是稳定的!
堆排序
堆排序就是利用堆进行排序的算法,它的基本思想是:将待排序的序列构造成一个大堆(或小堆)。此时,整个序列的最大值就是堆顶的根结点,将它移走(就是将其与堆数组的末尾元素交换,此时末尾元素就是最大值)。然后将剩余的n-1个序列重新构造成一个堆,这样就会得到n个元素中的最大值。如此反复进行,便能得一个有序的序列。
代码实现:
void AdjustDown(int* a, size_t n, int i) { int parent = i; int child = parent * 2 + 1; while (child < n) { if (child + 1 < n && a[child + 1] > a[child]) { ++child; } if (a[child] > a[parent]) { swap(a[parent] , a[child]); parent = child; child = parent * 2 + 1; } else { break; } } } void HeapSort(int *a, size_t n) { for (int i = (n - 2) / 2; i >= 0; i--) { AdjustDown(a, n, i); } int end = n - 1; while (end) { swap(a[0], a[end]); AdjustDown(a, end, 0); --end; } }
堆排序的时间复杂度和稳定性
堆排序的运行时间主要消耗在初始构建堆和在重建堆时,在构建堆的过程中,因为我们是完全二叉树从最下层最右边的非叶子节点开始构建,将它与其孩子进行比较,判断是否有必要交换,对于非叶子节点来说,最多进行两次比较和互换工作,因此整个构建堆的时间复杂度为O(n)。
在开始排序时,重建堆的时间复杂度为O(nlogn),所以总体来说,堆排序的时间复杂度为
O(logn).
冒泡排序
冒泡排序(Bubble Sort),又被称为气泡排序或泡沫排序。
它是一种较简单的排序算法。它会遍历若干次要排序的数列,每次遍历时,它都会从前往后依次的比较相邻两个数的大小;如果前者比后者大,则交换它们的位置。这样,一次遍历之后,最大的元素就在数列的末尾! 采用相同的方法再次遍历时,第二大的元素就被排列在最大元素之前。重复此操作,直到整个数列都有序为止!
代码实现:
void BubbleSort(int *a, size_t n) { for (size_t i = 0; i < n; i++) { int flag = 0; //初始化标记为0 for (size_t j = 0; j < n - i - 1; j++) //将a[0. . . i]中的最大数放在末尾 { if (a[j] > a[j + 1]) { //swap(a[j], a[j + 1]);//交换a[j]和a[j+1] int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; flag = 1; //若发生交换,则把标记置为1 } } if (flag == 0) //若没发生交换,则说明数组已经有序 { break; } } }
冒泡排序的时间复杂度和稳定性
冒泡排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N),需要遍历多少次呢?N-1次!因此,冒泡排序的时间复杂度是
O(N
2
)
。
冒泡排序是稳定的算法,它满足稳定算法的定义。
快速排序
快速排序使用
分治法策略
。
它的
基本思想
是:选择一个基准数,通过一趟排序将要排序的数据分割成独立的两部分;其中一部分的所有数据都比另外一部分的所有数据都要小。然后,再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
快速排序流程如下:
-
从数列中挑出一个基准值 。
-
将 所有比基准值小的摆放在基准前面,所有比基准值大的摆在基准的后面(相同的数可以到任一边);在这个分区退出之后,该基准就处于数列的中间位置。
-
递归 地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。
三种方法:
-
左右指针法
-
挖坑法
-
前后指针法
//左右指针法 int partSort1(int * a, int begin, int end) { int left = begin; int right = end; int key = a[right]; while (begin < end) { //begin找大 while (begin < end && a[begin] <= key) { ++begin; } //end赵小 while (begin < end && a[end] >= key) { --end; } swap(a[begin], a[end]); } swap(a[begin], a[right]); return begin; } void QuickSort(int* a, int left, int right) { if (left >= right) return; int div = partSort1(a, left, right); QuickSort(a, left, div - 1); QuickSort(a, div + 1, right); }
//挖坑法 int partSort2(int *a, int begin, int end) { int key = a[end]; while (begin < end) { while (begin < end && a[begin] <= key) { ++begin; } a[end] = a[begin]; while (begin < end && a[end] >= key) { --end; } a[begin] = a[end]; } a[begin] = key; return begin; } void QuickSort(int* a, int left, int right) { if (left >= right) return; int div = partSort2(a, left, right); QuickSort(a, left, div - 1); QuickSort(a, div + 1, right); }
//前后指针法 int partSort3(int *a, int begin, int end) { int key = a[end]; int prev = begin - 1; int cur = begin; while (cur < end) { if (a[cur] < key && ++prev != cur) { swap(a[prev], a[cur]); } ++cur; } swap(a[++prev], a[end]); return prev; } void QuickSort(int* a, int left, int right) { if (left >= right) return; int div = partSort3(a, left, right); QuickSort(a, left, div - 1); QuickSort(a, div + 1, right); }
快排优化
-
三数取中法
-
尾递归
当插入的数小于等于常数时用直接插入排序,在这里我们一般设置为小于等于7。
三数取中法:
三数取中法:
排序速度的快慢取决于关键字key处在整个序列的位置,key太小或太大都会影响性能,改进方法就是三数取中法,取三个关键字先进行排序,将中间的数作为key,一般取左端、右端和中间三个数,也可以随机选取。
//三数取中法 #define MAX_LENGTH_INSERT_SORT 7 void _InsertSort(int *a, size_t n) { for (size_t i = 0; i < n - 1; i++) { int end = i; int tmp = a[end + 1]; while (end >= 0) { if (a[end] > tmp) { a[end + 1] = a[end]; --end; } else { break; } } a[end + 1] = tmp; } } void InsertSort(int *a, int left, int right) { _InsertSort(a + left, right - left + 1); } int partSort2(int *a, int begin, int end) { int mid = begin + (end - begin) / 2; if (a[end] > a[begin]) { swap(a[begin], a[end]); } if (a[mid] > a[begin]) { swap(a[mid], a[begin]); } if (a[mid] > a[end]) { swap(a[mid], a[end]); } int key = a[end]; while (begin < end) { while (begin < end && a[begin] <= key) { ++begin; } a[end] = a[begin]; while (begin < end && a[end] >= key) { --end; } a[begin] = a[end]; } a[begin] = key; return begin; } void QuickSort(int* a, int left, int right) { if ((right - left) > MAX_LENGTH_INSERT_SORT) { int div = partSort2(a, left, right); QuickSort(a, left, div - 1); QuickSort(a, div + 1, right); } else //当 right - left 小于等于常数时用直接插入排序 { InsertSort(a, left, right); } }
尾递归:
递归对性能是有一定影响的,partSort函数在其尾部有两次递归操作。如果带排序的序列划分极端的不平衡,递归深度将趋近于n,而不是平衡时的logn。栈的大小是很有限的,每次调用都会耗费一定的栈空间,函数的参数越多,每次递归耗费的空间也就越多,因此如果能减少递归,将会大大提高性能。
//尾递归 #define MAX_LENGTH_INSERT_SORT 7 //数组长度阈值 void _InsertSort(int *a, size_t n) { for (size_t i = 0; i < n - 1; i++) { int end = i; int tmp = a[end + 1]; while (end >= 0) { if (a[end] > tmp) { a[end + 1] = a[end]; --end; } else { break; } } a[end + 1] = tmp; } } void InsertSort(int *a, int left, int right) { _InsertSort(a + left, right - left + 1); } int partSort2(int *a, int begin, int end) { int mid = begin + (end - begin) / 2; if (a[end] > a[begin]) { swap(a[begin], a[end]); } if (a[mid] > a[begin]) { swap(a[mid], a[begin]); } if (a[mid] > a[end]) { swap(a[mid], a[end]); } int key = a[end]; while (begin < end) { while (begin < end && a[begin] <= key) { ++begin; } a[end] = a[begin]; while (begin < end && a[end] >= key) { --end; } a[begin] = a[end]; } a[begin] = key; return begin; } void QuickSort(int* a, int left, int right) { if ((right - left) > MAX_LENGTH_INSERT_SORT) { while (left < right) { int div = partSort2(a, left, right); if (div - left < right - div) { QuickSort(a, left, div - 1); left = div + 1; } else { QuickSort(a, div + 1, right); right = div - 1; //尾递归 } } } else { InsertSort(a, left, right); } }
快速排序的时间复杂度和稳定性
快速排序的
时间复杂度
:
快速排序的时间复杂度在最坏情况下是
O(N
2
),
平均的时间复杂度是
O(N*lgN)
。这句话很好理解:假设被排序的数列中有N个数。
遍历一次
的时间复杂度是
O(N)
,需要
遍历
多少次呢?
至少lg(N+1)次
,
最多N
次
。
为什么最少是lg(N+1)次?快速排序是采用的分治法进行遍历的,我们将它看作一棵二叉树,它需要遍历的次数就是二叉树的深度,而根据完全二叉树的定义,它的深度至少是lg(N+1)。因此,快速排序的遍历次数最少是lg(N+1)次。
为什么最多是N次?还是将快速排序看作一棵二叉树,它的深度最大是N。因此,快速排序的遍历次数最多是N次。
快速排序的稳定性:快速排序是不稳定的算法,它不满足稳定算法的定义。
归并排序
归并排序就是利用归并的思想实现的排序方法。它的原理是假设初始序列有n个记录,则可以看成是n个有序的子序列,每个子序列的长度为1或2,然后两两归并,得到[n/2]个长度为2 或1的有序子序列,再两两归并,.......,如此重复,直至得到一个长度为n的有序序列为止。这种方法称为2路归并排序。
//归并排序 递归实现 void MergeSort(int *a, size_t n) { int * tmp = new int[n]; _MergeSort(a, 0, n - 1, tmp); delete[] tmp; } void _MergeSort(int *a, int left, int right, int *tmp) { if (left >= right) return; int mid = left + ((right - left) >> 1); //[left, mid] [mid+1, right] //保证两段子区间有序,再归并 _MergeSort(a, left, mid, tmp); _MergeSort(a, mid + 1, right, tmp); //归并 int begin1 = left, end1 = mid; int begin2 = mid + 1, end2 = right; int index = left; while (begin1 <= end1 && begin2 <= end2) { if (a[begin1] < a[begin2]) { tmp[index++] = a[begin1++]; } else { tmp[index++] = a[begin2++]; } } while (begin1 <= end1) { tmp[index++] = a[begin1++]; } while (begin2 <= end2) { tmp[index++] = a[begin2++]; } index = left; while (index <= right) { a[index] = tmp[index]; ++index; } }
归并排序的时间复杂度和稳定性
归并排序总的时间复杂度O(nlogn),这是归并排序算法中最好、最坏、平均的时间性能。
归并排序是一种比较占用内存,但却效率高且
稳定
的算法。