一、冒泡排序
思路：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两记录交换，然后比较第二个记录和第三个记录的关键字，依次类推，直到第n-1个记录和第n个记录的关键字比较完毕为止。此过程为第一趟冒泡排序，结果使得最大的关键字被放置到最后一个记录的位置上。
图一 冒泡排序示例
代码：
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include <math.h>
typedef struct stack
{
int *data;
int top;
}Stack;
typedef struct Que
{
int *data;
int head;
int tail;
}Que;
void Swap(int *a, int *b)
{
int c = *a;
*a = *b;
*b = c;
}
// O(n^2) O(1) 稳定
void BubbleSort(int *arr, int len)
{
int i = 0;
int j = 0;
for(i=0; i<len-1; ++i)
{
for(j=0; j<len-1-i; ++j)
{
if(arr[j] > arr[j+1])
{
Swap(&arr[j], &arr[j+1]);
}
}
}
}其中时间复杂度为O(
)，空间复杂度为O(n)，稳定性是不稳定的。
稳定：如果a原本在b的前面，而a=b, 排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，a=b, 排序之后a有可能在b的后面。
时间复杂度：对排序数据的总的操作次数。
空间复杂度：指算法在计算机内执行时所需存储空间的度量。
二、选择排序
参考本人另一条博客内容，相关链接为https://blog.csdn.net/qq_41026740/article/details/79706790
// O(n^2) O(1) 不稳定
void SelectSort(int *arr, int len)
{
int min = 0;
for (int i = 0; i < len; ++i)
{
min = i;
for (int j = i + 1; j < len; ++j)
{
if (arr[j] < arr[min])
{
min = j;
}
}
if (min != i)
{
Swap(&arr[min], &arr[i]);
}
}
}三、直接插入排序
思路：以第二个数据开始，插入到数据前已排序好的数据序列中，并使其依旧有序。（示例：扑克调牌）
图二 直接插入排序示例
代码：
void InsertSort(int *arr, int len)
{
int tmp = 0; //tmp保存每次插入的数据
for(int i=1; i<len; ++i)
{
tmp = arr[i];
for(int j=i-1; j>=0; --j)
{
if(arr[j] > tmp)
{
arr[j+1] = arr[j];
}
else
{
break;
}
}
arr[j+1] = tmp;
}
}时间复杂度最坏为O(), 最好为O(n); 空间复杂度为O(1), 稳定性是稳定的。
四、希尔排序
思路：先跨越式分组，使用直接插入排序，使每组数据有序，随着分的组越来越详细，整个数据变得越来越有序，直到分组成员只有1个时，排序完成。
图三 希尔排序示例
代码：
void Shell(int *arr, int len, int width)
{
for (int i = width; i < len; ++i)
{
int tmp = arr[i];
int j = 0;
for (j = i - width; j >= 0; j -= width)
{
if (arr[j] > tmp)
{
arr[j + width] = arr[j];
}
else
{
break;
}
}
arr[j + width] = tmp;
}
}
//O(n^1.3) - O(n^1.5) O(1) 不稳定
void ShellSort(int *arr, int len)
{
int d[] = { 5, 3, 1 }; // 最后一个数据必须是1
for (int i = 0; i < sizeof(d) / sizeof(d[0]); ++i)
{
Shell(arr, len, d[i]);
}
}
五、快速排序
思路：每选取一个数（待排列数据的第一个数据）作为比较的基准，然后从后往前找比基准小的，将其放在前面空缺位置，其次从前往后找比基准大的数据放在后面空缺位置，直到 i 和 j 相遇。将基准放入 i 位置，基准前的数据都比基准小，基准后的数据都比基准大，然后递归分别处理左半边和右半边。
递归与非递归的区别
非递归：排序前开辟一块空间，更稳定，代码复杂，逻辑复杂；
递归：边排序边开辟空间，代码简单，逻辑简单。
// O(n) O(1) 不稳定
int OnceQuick(int *arr, int left, int right)
{
int i = left;
int j = right;
int tmp = arr[i];
while (i < j)
{
// 从后往前找第一个比基准小的数据
while (i < j && arr[j] >= tmp) j--;
//undo
if (i == j)
{
break;
}
arr[i] = arr[j];
//从前往后找第一个比基准大的数据
//undo
while (i < j && arr[i] <= tmp) i++;
if (i == j)
{
break;
}
arr[j] = arr[i];
}
arr[i] = tmp;
return i;
}
// 递归完成 O(nlogn) O(logn)
void Quick(int *arr, int left, int right)
{
// 快排的一次处理过程
int pos = OnceQuick(arr, left, right);
if (pos - left > 1)
{
Quick(arr, left, pos - 1); // 递归处理基准左边的数据
}
if (right - pos > 1)
{
Quick(arr, pos + 1, right); //递归处理基准右边的数据
}
}
// 非递归完成
void Quick2(int *arr, int left, int right)
{
Stack st;
int n = right - left + 1;
int len = (int)(log10((double)n) / log10((double)2)) + 1; // logn
st.data = (int *)malloc(2 * sizeof(int) * len);
assert(st.data != NULL);
st.top = 0;
st.data[st.top++] = left;
st.data[st.top++] = right;
while (st.top != 0)
{
right = st.data[--st.top];
left = st.data[--st.top];
int pos = OnceQuick(arr, left, right);
if (right - pos > 1)
{
st.data[st.top++] = pos+1;
st.data[st.top++] = right;
}
if (pos - left > 1)
{
st.data[st.top++] = left;
st.data[st.top++] = pos - 1;
}
}
free(st.data);
}
// O(nlogn) O(logn) 不稳定
void QuickSort(int *arr, int len)
{
//Quick(arr, 0, len - 1);
Quick2(arr, 0, len - 1);
}六、堆排序
小根堆：在二叉树结构中，父节点比左右孩子都小
大根堆：在二叉树结构中，父节点比左右孩子都大
①设父节点为 i
左孩子：2*i+1
右孩子：2*i-1
②设孩子节点为 i
父节点：（i-1）/2
调整到大根堆的过程：
1、整个调整过程从最后一个子树开始，依次向上调整；
2、每次调整都是从这棵子树的根节点开始往下调整。
堆排序与数据原本的顺序无关。
//O(logn) O(1) 不稳定
void Adjust(int *arr, int len, int start)
{
int tmp = arr[start];
int i = start * 2 + 1;
while (i < len)
{
if (i + 1 < len && arr[i + 1] > arr[i])
{
i += 1;
}
// 上一步判断完成后，则i位左右孩子较大的哪一个
if (arr[i] < tmp)
{
break;
}
arr[start] = arr[i];
start = i;
i = 2 * start + 1;
}
arr[start] = tmp;
}
//O(nlogn) O(1)
void CreateHeap(int *arr, int len)
{
for (int i = (len - 2) / 2; i >= 0; --i)
{
Adjust(arr, len, i);
}
}
// O(nlogn) O(1) 不稳定
void HeapSort(int *arr, int len)
{
CreateHeap(arr, len);
int end = len - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
Adjust(arr, end, 0);
end--;
}
}七、二路归并
// 二路归并 O(n) O(n) 稳定
void Meger(int *arr, int len, int width)
{
int low1 = 0;
int high1 = low1 + width - 1; // -1使得high1为本段最后一个元素的下标
int low2 = high1 + 1;
int high2 = low2 + width - 1 < len - 1 ? low2 + width - 1 : len - 1;
int *brr = (int *)malloc(sizeof(int) * len);
assert(brr != NULL);
int index = 0;
while (low1 < len) //只要有一个段还没合并进brr中，循环都得执行
{
//按顺序归并两个相邻的段， 退出时，有可能第一个段数据归并完成
//也有可能是第二个段数据归并完成
while (low1 <= high1 && low2 <= high2)
{
if (arr[low1] < arr[low2])
{
brr[index++] = arr[low1++];
}
else
{
brr[index++] = arr[low2++];
}
}
//将第一个段剩余的数据存储到brr中
while (low1 <= high1)
{
brr[index++] = arr[low1++];
}
//将第二个段剩余的数据存储到brr中
while (low2 <= high2)
{
brr[index++] = arr[low2++];
}
// 继续往后归并剩余的段
low1 = high2 + 1;
high1 = low1 + width - 1 < len - 1 ? low1 + width - 1 : len - 1;
low2 = high1 + 1;
high2 = low2 + width - 1 < len - 1 ? low2 + width - 1 : len - 1;
}
for (int i = 0; i < len; ++i)
{
arr[i] = brr[i];
}
free(brr);
}
// O(nlogn) O(n) 稳定
void MegerSort(int *arr, int len)
{
for (int i = 1; i < len; i *= 2)
{
Meger(arr, len, i);
}
}八、基数排序
八种排序算法中，唯一不需要数据比较的算法。
出现多个关键字可以用此排序算法。
条件：数据必须全为正整数。
思路：1、找到其中最大的数据，求位数；
2、再循环根据相应位数的值将数据放入对应的队列中；
3、按照队列顺序将队列中的所有数据输出。
//O(n)
int GetWidth(int *arr, int len)
{
int max = arr[0];
for (int i = 1; i < len; ++i)
{
if (arr[i] > max)
{
max = arr[i];
}
}
// 根据max求位数 1234 234
int width = 0;
while (max > 0)
{
width += 1;
max /= 10;
}
return width;
}
// 1234
// O(d)
int GetRadixVal(int val, int digit) // val = 1234 digit = 0
{
while (digit > 0)
{
val /= 10;
digit--;
}
return val % 10;
}
//O(dn) O(n) 稳定
void RadixSort(int *arr, int len)
{
Que que[10];
for (int i = 0; i < 10; ++i)
{
que[i].data = (int *)malloc(sizeof(int)* len);
assert(que[i].data != NULL);
que[i].head = que[i].tail = 0;
}
int width = GetWidth(arr, len);
for (int i = 0; i < width; ++i)
{
for (int j = 0; j < len; j++)
{
int digitval = GetRadixVal(arr[j], i);
que[digitval].data[que[digitval].tail++] = arr[j];
}
int count = 0;
for (int k = 0; k < 10; ++k)
{
while (que[k].head != que[k].tail)
{
arr[count++] = que[k].data[que[k].head++];
}
que[k].head = que[k].tail = 0;
}
}
for (int i = 0; i < 10; ++i)
{
free(que[i].data);
}
}
//输出函数
void Show(int arr[], int len)
{
for (int i = 0; i < len; ++i)
{
printf("%d ", arr[i]);
}
printf("\n");
}主函数的测试代码：
int main()
{
int arr[] = {35,26,13,228,65,45,139,42,717,239,83, 123,563,1276};
int len = sizeof(arr) / sizeof(arr[0]);
//BubbleSort(arr, len);冒泡排序
//SelectSort(arr, len);选择排序
//QuickSort(arr, len);快速排序
//HeapSort(arr, len);堆排序
//MegerSort(arr, len);二路归并排序
RadixSort(arr, len);//基数排序
Show(arr, len);
}
