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)，这是归并排序算法中最好、最坏、平均的时间性能。
归并排序是一种比较占用内存，但却效率高且
稳定
的算法。