一、排序概念
1. 排序：将一组杂乱无章的数据按照一定的规律组织起来，就称为排序。
2. 数据表：待排序的数据元素的有限集合。
3. 排序码：通常数据元素有多个属性域，其中有一个属性域可以用来区分元素，作为排序依据，该域即为排序码。
* 若在数据表中各个元素的排序码各不相同，这种排序码称为主排序码。
* 按照主排序码进行排序，排序的结果是唯一的。
* 按照次排序码进行排序，排序结果不唯一。
二、排序算法的稳定性
如果在元素序列中有两个元素R[i]和R[j]，他们的排序码K[i]==K[j]，且在排序之前，R[i]在R[j]前面。若在排序后，R[i]仍然在R[j]前面，则称这个算法是稳定的。否则，这个算法是不稳定的。
三、经典排序算法
算法总结
3.1.插入排序
3.1.1直接插入排序
基本思想：
当插入第i个元素时，前面的array[0]、array[1]、array[2]……array[i-1]已经排好序，此时用array[i]的排序码与array[i-1]、array[i-2]……的排序码进行比较，找到插入位置将array[i]插入，原来位置上的元素顺序右移。
动画演示：
代码实现：
////////////////////插入排序//////////////////////////
//插入排序
//时间复杂度：O(n^2)
//空间复杂度：O(1)
//稳定性：稳定
void InsertSort(int* array,int size)
{
//[0,end] end+1插入
for (int i = 1; i < size; ++i)
{
int key = array[i];//当前元素的排序码
int end = i - 1;
while (end >= 0 && array[end] > key)//找插入位置
{
array[end + 1] = array[end];
end--;
}
array[end + 1] = key;//插入
}
}改进：二分法插入排序
优点：查找更快，减少比较操作的次数，效率更高。
//二分插入排序
void InsertSort_OP(int* array, size_t size)
{
for (int i = 1; i < size; i++)
{
//在已序序列中查找待插入元素的位置
int left = 0;
int right = i - 1;
int key = array[i];
while (left <= right)
{
int mid = left + ((right - left) >> 1);
if (key < array[mid])
right = mid - 1;
else
left = mid + 1;
}
//搬移元素
int end = i - 1;
while (end >= left)
{
array[end + 1] = array[end];
end--;
}
//插入元素
array[left] = key;
}
}
3.1.2 希尔排序
基本思想：
希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
动画实现：
代码实现：
//希尔排序
//时间复杂度：O(n^1.25 ~ 1.6n^1.25)
//空间复杂度：O(1)
//稳定性：稳定
//适用场景：数据量大
/*
void ShellSort(int* array, size_t size)
{
int gap = 3;
while (gap)
{
for (size_t i = gap; i < size; ++i)
{
int key = array[i];
int end = i - gap;
//找到当前需要插入元素的位置
while (end >= 0 && array[end] > key)
{
array[end + gap] = array[end];
end -= gap;
}
//插入元素
array[end + gap] = key;
}
gap--;
}
}
*/
void ShellSort(int* array, size_t size)
{
int gap = size;
while (gap > 1)
{
gap = gap / 3 + 1;//经过大量计算得到此类方法时间复杂度较低
for (size_t i = gap; i < size; ++i)
{
int key = array[i];
int end = i - gap;
//找到当前需要插入元素的位置
while (end >= 0 && array[end] > key)
{
array[end + gap] = array[end];
end -= gap;
}
//插入元素
array[end + gap] = key;
}
}
}3.2 选择排序
3.2.1 选择排序
基本思想：
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。
动画实现：
代码实现：
//选择排序
//时间复杂度：O(N^2)
//空间复杂度：O(1)
//稳定性：不稳定
void SelectSort(int* array, size_t size)
{
int begin = 0;
int end = size - 1;
while (begin < end)
{
int min = begin;
int max = end;
for (size_t i = begin; i < end; ++i)
{
if (array[i] < array[min])
min = i;
if (array[i] > array[max])
max = i;
}
swap(array[begin], array[min]);
//修正
if (min == end)
min = max;
swap(array[end], array[max]);
++begin;
--end;
}
}
3.2.2 堆排序
基本思想：
将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
动画实现：
代码实现：
//堆排序之向下调整
void AdjustDown(int* array, size_t size, int root)
{
int parent = root;
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && array[child + 1] > array[child])
{
child++;
}
if (array[child] > array[parent])
{
swap(array[child], array[parent]);
parent = child;
child = child * 2 + 1;
}
else
{
break;
}
}
}
//堆排序
//时间复杂度：O(n*lgN)
//空间复杂度：O(1)
//稳定性：不稳定
void HeapSort(int* array, size_t size)
{
//调整堆
for (int i = (size - 2) / 2; i >= 0; --i)
{
AdjustDown(array, size, i);//向下调整
}
//排序
int end = size - 1;
while (end >= 0)
{
swap(array[end], array[0]);
AdjustDown(array, end, 0);
end--;
}
}
3.3 交换排序
3.3.1 冒泡排序
基本思想：
设序列中有n个数据元素，循环进行n-1趟如下排序：
第1趟：依次比较相邻两个数据元素(i = 0,1,2,…, n-2),若array[i]>array[i+1],则交换两个元
素，否则不交换，这样数值最大的数据元素将被防止在a[n-1]中；
第2趟：数据个数减1，即数据元素个数为n-1，操作方式和1类似，排完之后数据序列中的次大元素
保存在array[n-2]中；
当n-1趟结束时，排序结束。
动画实现：
代码实现：
//冒泡排序
//时间复杂度：O(N^2)
//空间复杂度：O(1)
//稳定性：稳定
void BubbleSort(int* array, size_t size)
{
for (size_t end = size; end > 0; --end)
{
bool exchange = false;
for (size_t i = 1; i < end; i++)
{
if (array[i - 1]>array[i])
{
swap(array[i - 1], array[i]);
exchange = true;
}
}
if (exchange == false)
break;
}
}冒泡排序与插入排序的区别：插入排序更优
1 2 3 5 4
冒泡排序：(n-1)+(n-2)
插入排序：n
3.3.2 快速排序
基本思想：
通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
递归实现：
//递归实现
void QuickSort(int* array, int left, int right)
{
if (left >= right)
return;
/*
//小区间优化
if (right - left + 1 < 5)//16
{
InsertSort(array + left, right - left + 1);
return;
}
*/
int div = PartSort1/PartSort2/PartSort3/PartSort4(array, left, right);//快排分开的位置
QuickSort(array, left, div - 1);//[left,div-1]
QuickSort(array, div + 1, right);//[div+1,right]
}非递归实现：
#include <stack>
//非递归
void QuickSortNor(int* array, int left, int right)
{
stack<int> s;
s.push(right);
s.push(left);
while (!s.empty())
{
int begin = s.top();
s.pop();
int end = s.top();
s.pop();
int div = PartSort1/PartSort2/PartSort3/PartSort4(array, begin, end);
if (begin < div - 1)
{
s.push(div - 1);
s.push(begin);
}
if (div + 1 < end)
{
s.push(end);
s.push(div + 1);
}
}
}快排分开位置的几种方法：
1.begin找大,end找小
int PartSort1(int* array, int begin, int end)
{
int& key = array[end];//将最后一个元素作为中间元素
while (begin < end)
{
while (begin < end && array[begin] <= key)//注意：等号的情况得考虑进去，防止第一个元素与最后一个元素相等
++begin;
while (begin < end && array[end] >= key)
--end;
swap(array[begin], array[end]);
}
swap(array[begin], key);
return begin;
}//优化
//三数取中---获取中间元素的下标
int GetMidIndex(int* array, int begin, int end)
{
int mid = begin + ((end - begin) >> 1);
//begin mid
if (array[mid] > array[begin])
{
if (array[end] > array[mid])//begin mid end
return mid;
else if (array[end] > array[begin])//begin end mid
return end;
else
return begin;
}
//mid begin
else
{
if (array[end] < array[mid])//end mid begin
return mid;
else if (array[end] >array[begin])//mid begin end
return begin;
else
return end;
}
}
2.左右指针法
int PartSort2(int* array, int begin, int end)
{
int mid = GetMidIndex(array, begin, end);
swap(array[mid], array[end]);
int& key = array[end];//将最后一个元素作为中间元素
while (begin < end)
{
while (begin < end && array[begin] <= key)//注意：等号的情况得考虑进去，防止第一个元素与最后一个元素相等
++begin;
while (begin < end && array[end] >= key)
--end;
swap(array[begin], array[end]);
}
swap(array[begin], key);
return begin;
}
3.挖坑法
int PartSort3(int* array, int begin, int end)
{
int& key = array[end];
while (begin < end)
{
while (array[begin] < key)
{
++begin;
}
array[end] = array[begin];//填坑
while (array[end] > key)
{
--end;
}
array[begin] = array[end];//填坑
}
array[begin] = key;
return begin;
}4.前后指针法
int PartSort4(int* array, int begin, int end)
{
int prev = begin - 1;
int cur = begin;
int key = array[end];
while (cur < end)
{
if (array[cur] < key&&++prev != cur)//cur找小
swap(array[cur], array[prev]);//交换，小的放左，大的放右
++cur;
}
swap(array[++prev], array[end]);
return prev;
}3.4 归并排序
基本思想：
基本思想：将待排序的元素序列分成两个长度相等的子序列，为每一个子序列排序，然后将他们合并成一个序列。合并两个子序列的过程称为两路归并。
动画实现：
代码实现：
//时间复杂度：O(N*logN)
//空间复杂度：O(N)
//稳定性：稳定
#include <assert.h>
//[left,right]
void _MergeSort(int* array, int left, int right, int* tmp)
{
if (left >= right)
return;
int mid = left + ((right - left) >> 1);
//[left,mid] [mid+1,right] 均为有序区间
_MergeSort(array, left, mid, tmp);
_MergeSort(array, mid + 1, right, tmp);
int begin1 = left;
int end1 = mid;
int begin2 = mid + 1;
int end2 = right;
int index = left;
//从头开始比较大小，小的放在新空间中，继续往后走
while (begin1 <= end1 && begin2 <= end2)
{
if (array[begin1] < array[begin2])
tmp[index++] = array[begin1++];
else
tmp[index++] = array[begin2++];
}
//[begin2,end2]走完,将[begin1,end1]剩下的元素放入新空间中
while (begin1 <= end1)
{
tmp[index++] = array[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = array[begin2++];
}
memcpy(array + left, tmp + left, (right - left + 1)*sizeof(int));
}
void MergeSort(int* array, size_t size)
{
assert(array);
//开辟一个新空间
int* tmp = new int[size];
_MergeSort(array, 0, size - 1, tmp);
delete[] tmp;
}3.5 计数排序
基本思想：
利用哈希的方法，将每个数据出现的次数都统计下来。哈希表是顺序的，所以我们统计完后直接遍历哈希表，将数据再重写回原数据空间就可以完成排序。
动画实现：
代码实现：
//时间复杂度：O(N+数据范围)
//空间复杂度：O(最大数-最小数)
//场景：正整数排序
void CountSort(int* array, size_t size)
{
//计算相对位置
int min = array[0];
int max = array[0];
for (size_t i = 0; i < size; ++i)
{
if (array[i] < min)
min = array[i];
if (array[i] > max)
max = array[i];
}
int range = max - min + 1;
int* counts = new int[range];
memset(counts, 0, range*sizeof(int));
for (size_t i = 0; i < size; ++i)
{
counts[array[i] - min]++;//相对位置
}
//借助counts数组将元素放入原空间中
int j = 0;
for (size_t i = 0; i < range; ++i)
{
while (counts[i]--)
{
array[j++] = i + min;
}
}
//释放辅助空间
delete[] counts;
}3.6 基数排序
基本思想：
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
①LSD–Least Significant Digit first 从低位（个位）向高位排。
②MSD– Most Significant Digit first 从高位向低位（个位）排。
动画实现：
代码实现：
//LSD(先排低位) MSD(先排高位)
//时间复杂度：O(N*基数)
//空间复杂度：O(N)
//场景：正整数排序
void LSDSort(int* array, size_t size)
{
//统计数据中最大数的位数
int digits = 1;//至少是个位数
int base = 10;
for (size_t i = 0; i < size; ++i)
{
while (array[i] >= base)
{
++digits;
base *= 10;
}
}
int* buckets = new int[size];//开辟临时空间
base = 1;
for (size_t i = 0; i < digits; ++i)
{
//0~9号桶中存放数据的个数
int counts[10] = { 0 };
for (size_t i = 0; i < size; ++i)
{
int num = (array[i]/base) % 10;
counts[num]++;
}
//0~9号桶第一个数据的起始位置
int starts[10] = { 0 };
for (size_t i = 1; i < 10; ++i)
{
starts[i] = starts[i - 1] + counts[i - 1];
}
for (size_t i = 0; i < size; ++i)
{
int num = (array[i] / base) % 10;//个位是几，num表示几号桶
int index = starts[num]++;//每放入一个数据在桶里，就给起始位置++
buckets[index] = array[i];//将数据放入桶中
}
memcpy(array, buckets, sizeof(int)*size);
base *= 10;
}
delete[] buckets;
}测试代码：
void test()
{
int array[] = { 3, 4, 1, 5, 8, 6, 9, 0 };
//InsertSort(array, sizeof(array) / sizeof(array[0]));
//InsertSort_OP(array, sizeof(array) / sizeof(array[0]));
//ShellSort(array, sizeof(array) / sizeof(array[0]));
//SelectSort(array, sizeof(array) / sizeof(array[0]));
//HeapSort(array, sizeof(array) / sizeof(array[0]));
//BubbleSort(array, sizeof(array) / sizeof(array[0]));
//QuickSort(array, 0, sizeof(array) / sizeof(array[0]) - 1);
//QuickSortNor(array, 0, sizeof(array) / sizeof(array[0]) - 1);
//MergeSort(array, sizeof(array) / sizeof(array[0]));
//CountSort(array, sizeof(array) / sizeof(array[0]));
LSDSort(array, sizeof(array) / sizeof(array[0]));
Print(array, sizeof(array) / sizeof(array[0]));
}
327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
