1. 熟悉排序的相关概念：什么是排序，排序的稳定性，内部排序与外部排序
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法
冒泡排序、插入排序、归并排序和基数排序都是稳定的排序算法。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
2. 熟悉插入、希尔、选择、堆排、冒泡、归并、计数、基数排序的以下内容：
排序原理、代码实现、稳定性、时间空间复杂度、应用场景
插入排序：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一 个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
直接插入排序的特性总结：
1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定
void InsertSort(int *array, int size)
{
for (int i = 1; i < size; ++i)
{
int key = array[i];
int end = i - 1;
//搬移元素
while ((end >= 0) && (key < array[end]))
{
array[end + 1] = array[end];
end--;
}
//插入
array[end + 1] = key;
}
}
希尔排序：希尔排序法又称缩小增量法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
希尔排序的特性总结：
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N^1.3—N^2）
4. 稳定性：不稳定
void ShellSort(int *array, int size)
{
int gap = size;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int i = gap; i < size; ++i)
{
int key = array[i];
int end = i - gap;
//搬移元素
while ((end >= 0) && (key < array[end]))
{
array[end + gap] = array[end];
end -= gap;
}
//插入
array[end + gap] = key;
}
}
}
选择排序：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的 数据元素排完 。
直接选择排序的特性总结：
1. 直接选择排序思考非常好理解，但是效率不是很好，实际中很少使用。
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
void Swap(int* pLeft, int* pRight)
{
int temp = *pLeft;
*pLeft = *pRight;
*pRight = temp;
}
//会进行多次重复比较
void SelectSort(int* array, int size)
{
for (int i = 0; i < size - 1; ++i)
{
//找区间中最大元素的位置
int maxPos = 0;
for (int j = 1; j < size - i; ++j)
{
if (array[j] > array[maxPos])
maxPos = j;
}
if (maxPos != (size - i - 1))
Swap(&array[maxPos], &array[size - i - 1]);
}
}
//时间复杂度：O(N ^ 2)快于上面
//空间复杂度：O(1)
//稳定性：不稳定
void SelectSort_OP(int* array, int size)
{
int begin = 0;
int end = size - 1;
while (begin < end)
{
int maxPos = begin;
int minPos = begin;
int i = begin;
//在区间找到最大和最小元素的位置
while (i <= end)
{
if (array[i] > array[maxPos])
maxPos = i;
if (array[i] < array[minPos])
minPos = i;
++i;
}
if (maxPos != end)
Swap(&array[maxPos], &array[end]);
if (minPos == end)
minPos = maxPos;
if (minPos != begin)
Swap(&array[minPos], &array[begin]);
begin++;
end--;
}
}
堆排序：堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
//时间复杂度：O(log2(N))
void HeapAdjust(int* array, int size, int parent)
{
// 默认child标记左孩子
int child = parent * 2 + 1;
while (child < size)
{
// 找左右孩子中最大的
if (((child + 1) < size) && (array[child + 1] > array[child]))
child += 1;
// 检测双亲是否满足堆的性质
if (array[child] > array[parent])
{
Swap(&array[child], &array[parent]);
parent = child;
child = parent * 2 + 1;
}
else
return;
}
}
//时间复杂度：O(Nlog2(N))
//空间复杂度：O(1)
//稳定性：不稳定
//应用场景：找前 K 个最大/最小元素(TopK问题)
//堆排序
void HeapSort(int* array, int size)
{
// 建堆---升序(大堆) 降序(小堆)
// 从倒数第一个非叶子节点---向下调整
int last = (size - 2) / 2;
for (; last >= 0; last--)
HeapAdjust(array, size, last);
// 排序---堆删除
int end = size - 1;
while (end)
{
Swap(&array[0], &array[end]);
HeapAdjust(array, end, 0);
--end;
}
}
冒泡排序：它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
冒泡排序的特性总结：
1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定
void BubbleSort(int* array, int size)
{
//size - 1;
for (int i = 0; i < size - 1; ++i)
{
//冒泡的方式--->用相邻元素进行比较
int IsChange = 0;
for (int j = 1; j < size - i; ++j)
{
if (array[j - 1] > array[j])
{
Swap(&array[j - 1], &array[j]);
IsChange = 1;
}
}
if (IsChange == 0)
return;
}
}快速排序：快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法。任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：
1.hoare版本
2.挖坑法
3.前后指针版本
快速排序优化
1.三数取中法选key
2.递归到小的子区间时，可以考虑使用插入排序
快速排序的特性总结：
1.快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2.时间复杂度：O(N*logN)*
3.空间复杂度：O(logN)
4.稳定性：不稳定
//基数
// 用三数取中法
int GetMiddleIdx(int* array, int left, int right)
{
int mid = left + ((right - left) >> 1);
// left mid right-1
if (array[left] < array[right - 1])
{
if (array[mid] < array[left])
return left;
else if (array[mid] > array[right - 1])
return right - 1;
else
return mid;
}
else
{
if (array[mid] > array[left])
return left;
else if (array[mid] < array[right - 1])
return right - 1;
else
return mid;
}
}
//O(N)
//第一种分割方式（先从头找大于基准值的，再从最后找小于基准值的，然后交换）
int Partion1(int* array, int left, int right)
{
int middle = GetMiddleIdx(array, left, right);
if (middle != right - 1)
Swap(&array[middle], &array[right - 1]);
int key = array[right - 1];
int begin = left;
int end = right - 1;
while (begin < end)
{
//begin 从前往后找比基准值大的元素，找到就停下来
while ((begin < end) && (array[begin] <= key))
++begin;
//end 从后往前找比基准值小的元素，找到就停下来
while ((begin < end) && (array[end] >= key))
end--;
if (begin < end)
Swap(&array[begin], &array[end]);
}
if(begin!=right-1)
Swap(&array[begin], &array[right - 1]);
return begin;
}
//O(N)
//第二种划分方式(挖坑法)（先从头找大于基准值的，与基准值互换，再从最后找小于基准值的，填补上一个挖掉的值，拿掉一个用下一个找到的填补）
int Partion2(int* array, int left, int right)
{
int middle = GetMiddleIdx(array, left, right);
if (middle != right - 1)
Swap(&array[middle], &array[right - 1]);
int key = array[right - 1];
int begin = 0;
int end = right - 1;
while (begin < end)
{
while ((begin < end) && (array[begin] <= key))
begin++;
if (begin < end)
{
array[end] = array[begin];
end--;
}
while ((begin < end) && (array[end] >= key))
end--;
if (begin < end)
{
array[begin] = array[end];
begin++;
}
}
array[begin] = key;
return begin;
}
//O(N)
//第三种划分方式(两个指针中间的元素一定是比基准值大的)（cur从头找小于基准值的，找到之后让pre++，两个不相等则交换两个位置的元素，相等则继续往后找，两个指针之间的元素都是大于基准值的，最后pre++与基准值所在位置交换）
int Partion3(int* array, int left, int right)
{
int middle = GetMiddleIdx(array, left, right);
if (middle != right - 1)
Swap(&array[middle], &array[right - 1]);
int key = array[right - 1];
int cur = left;
int pre = cur - 1;
while (cur < right)
{
if (array[cur] < key && ++pre != cur)
Swap(&array[cur], &array[pre]);
cur++;
}
if (++pre != right - 1)
Swap(&array[pre], &array[right - 1]);
return pre;
}
//最差时间复杂度O(N^2)
//最好时间复杂度O(Nlog2(N))，经过优化一般就是O(Nlog2(N))
//稳定性：不稳定
//使用场景：数据越随机
//快速排序（递归）
void QuickSort(int* array, int left, int right)
{
//因为快速排序递归使用越往后区间元素越少，我们就可以使用插入排序
/*if ((right - left) < 16)
InsertSort(array, right - left);
else
{
int div = Partion3(array, left, right);
QuickSort(array, left, div);
QuickSort(array, div + 1, right);
}*/
if ((right - left) > 1)
{
int div = Partion3(array, left, right);
QuickSort(array, left, div);
QuickSort(array, div + 1, right);
}
}
#include "Stack.h" //需要使用栈
//快速排序（循环）
void QuickSortNor(int* array, int size)
{
int left = 0;
int right = size;
Stack s;
StackInit(&s);
StackPush(&s, right);
StackPush(&s, left);
// s: (div+1, right), (left, div)
while (!StackEmpty(&s))
{
left = StackTop(&s);
StackPop(&s);
right = StackTop(&s);
StackPop(&s);
if (left < right)
{
int div = Partion3(array, left, right);
StackPush(&s, right);
StackPush(&s, div + 1);
StackPush(&s, div);
StackPush(&s, left);
}
}
StackDestroy(&s);
}归并排序：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并排序的特性总结：
1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定
void MergeData(int* array, int left, int mid, int right, int* temp)
{
int begin1 = left, end1 = mid;
int begin2 = mid, end2 = right;
int index = left;
//将数组1和数组2有序插入数组temp
while ((begin1 < end1) && (begin2 < end2))
{
if (array[begin1] <= array[begin2])
{
temp[index] = array[begin1];
++index;
++begin1;
}
else
{
temp[index] = array[begin2];
++index;
++begin2;
}
}
//数组1 里面的元素没有搬完
while (begin1 < end1)
{
temp[index] = array[begin1];
++index;
++begin1;
}
//数组2 里面的元素没有搬完
while (begin2 < end2)
{
temp[index] = array[begin2];
++index;
++begin2;
}
}
void _MergeSort(int* array, int left, int right, int* temp)
{
if (right - left > 1)
{
//均分数组
int mid = left + ((right - left) / 2);
_MergeSort(array, left, mid, temp);
_MergeSort(array, mid, right, temp);
MergeData(array, left, mid, right, temp);
memcpy(array + left, temp + left, sizeof(array[left])*(right - left));
}
}
//归并排序（递归）（拆分数组，每个组都排序，排好后归并到一个数组）
void MergeSort(int* array, int size)
{
int* temp = (int*)malloc(size * sizeof(array[0]));
if (NULL == temp)
{
assert(0);
return;
}
_MergeSort(array, 0, size, temp);
free(temp);
}
//归并排序（循环）
void MergeSortNor(int* array, int size)
{
int* temp = (int*)malloc(size * sizeof(array[0]));
if (NULL == temp)
{
assert(0);
return;
}
int gap = 1;
while (gap < size)
{
for (int i = 0; i < size; i += 2 * gap)
{
int left = i;
int mid = left + gap;
int right = mid + gap;
if (mid >= size)
mid = size;
if (right >= size)
right = size;
MergeData(array, left, mid, right, temp);
}
memcpy(array, temp, sizeof(array[0])*size);
gap *= 2;
}
free(temp);
}
非比较排序：
1.计数排序（也叫鸽巢原理）：计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。
如果用快速排序，该算法的复杂度为O(nlog^2n)。改用计数排序后，复杂度降为O(nlogn)
计数排序算法是一个稳定的排序算法
场景：数据密集集中在某个范围中
时间复杂度：O(N) N: 代表数据的个数
空间复杂度：O(M) M: 数据的范围
void CountSort(int* array, int size)
{
int minVal = array[0];
int maxVal = array[0];
// 找数据的范围
for (int i = 1; i < size; ++i)
{
if (array[i] < minVal)
minVal = array[i];
if (array[i] > maxVal)
maxVal = array[i];
}
// 计算保存计数的空间
int range = maxVal - minVal + 1;
int* temp = (int*)malloc(sizeof(int)*range);
if (NULL == temp)
{
assert(0);
return;
}
memset(temp, 0, sizeof(int)*range); //按照一个一个字节设置空间，只能设置为0或者-1
// 统计每个数据出现的次数
for (int i = 0; i < size; ++i)
{
temp[array[i] - minVal]++;
}
// 回收
int index = 0;
for (int i = 0; i < range; ++i)
{
while (temp[i]--)
{
array[index++] = i + minVal;
}
}
free(temp);
}
基数排序：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
时间效率 ：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。
1633
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
