排序
1.插入排序：主要包括直接插入、折半插入、希尔排序
// 分类 ------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- 最坏情况为输入序列是降序排列的,此时时间复杂度O(n^2)
// 最优时间复杂度 ---- 最好情况为输入序列是升序排列的,此时时间复杂度O(n)
// 平均时间复杂度 ---- O(n^2)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 稳定
#include <stdio.h>
#include <stdlib.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void InertionSort(int array[], int len) // O(n*n)
{
int i = 0;
int j = 0;
int k = -1;
int temp = -1;
for (i = 1; i < len; i++)
{
k = i;
temp = array[k];
for (j = i - 1; (j >= 0) && (array[j] > temp); j--) // 有序序列
{
array[j + 1] = array[j];
k = j;
}
array[k] = temp;
}
}
int main(int argc, char *argv[])
{
int array[] = { 21,25,49,25,16,8 };
int len = sizeof(array) / sizeof(*array);
printf("插入排序前：");
println(array, len);
InertionSort(array, len);
printf("插入排序后：");
println(array, len);
system("pause");
return 0;
}
// 分类 -------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- O(n^2)
// 最优时间复杂度 ---- O(n^1.3)
// 平均时间复杂度 ---- O(nlogn)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 不稳定
#include <stdio.h>
#include <stdlib.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void ShellSort(int array[], int len)
{
int i = 0;
int j = 0;
int k = -1;
int temp = -1;
int gap = len;
do
{
gap = gap / 3 + 1; // gap如何变化无强制要求，但gap最终要收敛于1，工程实践经验除以3性能较好,现无理论方法证明。
//gap = 1; // gap=1时，希尔排序退化为擦入排序
// 分组
for (i = gap; i < len; i += gap)
{
k = i;
temp = array[k];
// 擦入排序
for (j = i - gap; (j >= 0) && (array[j] > temp); j -= gap)
{
array[j + gap] = array[j];
k = j;
}
array[k] = temp;
}
} while (gap > 1);
}
int main(int argc, char *argv[])
{
int array[] = { 21,25,49,25,16,8 };
int len = sizeof(array) / sizeof(*array);
printf("希尔排序前：");
println(array, len);
ShellSort(array, len);
printf("希尔排序前：");
println(array, len);
system("pause");
return 0;
}
2.交换排序：冒泡排序、快速排序
// 分类 -------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- O(n^2)(逆序)
// 最优时间复杂度 ---- 如果能在内部循环第一次运行时,使用一个旗标来表示有无需要交换的可能,可以把最优时间复杂度降低到O(n)
// 平均时间复杂度 ---- O(n^2)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 稳定
#include <stdio.h>
#include <stdlib.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void swap(int array[], int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
void BubbleSort(int array[], int len) // O(n*n)
{
int i = 0;
int j = 0;
int exchange = 1;
for (i = 0; (i < len) && exchange; i++)
{
exchange = 0; // exchange作优化，表示是否发生交换
for (j = len - 1; j > i; j--)
{
if (array[j] < array[j - 1])
{
swap(array, j, j - 1);
exchange = 1;
}
}
}
// printf("%d\n", i); // 标记趟数
}
int main(int argc, char *argv[])
{
int array[] = { 5,4,3,2,1 };
int len = sizeof(array) / sizeof(*array);
printf("冒泡排序前：");
println(array, len);
BubbleSort(array, len);
printf("冒泡排序后：");
println(array, len);
system("pause");
return 0;
}
// 分类 ------------ 内部比较排序
// 数据结构 --------- 数组
// 最差时间复杂度 ---- 每次选取的基准都是最大（或最小）的元素，导致每次只划分出了一个分区，需要进行n-1次划分才能结束递归，时间复杂度为O(n^2)
// 最优时间复杂度 ---- 每次选取的基准都是中位数，这样每次都均匀的划分出两个分区，只需要logn次划分就能结束递归，时间复杂度为O(nlogn)
// 平均时间复杂度 ---- O(nlogn)
// 所需辅助空间 ------ 主要是递归造成的栈空间的使用(用来保存left和right等局部变量)，取决于递归树的深度，一般为O(logn)，最差为O(n)
// 稳定性 ---------- 不稳定
#include <stdio.h>
#include <stdlib.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void swap(int array[], int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 划分过程
int partition(int array[], int low, int high)
{
int pv = array[low];
while (low < high)
{
while ((low < high) && (array[high] >= pv))
{
high--;
}
swap(array, low, high);
while ((low < high) && (array[low] <= pv))
{
low++;
}
swap(array, low, high);
}
return low;
}
void QSort(int array[], int low, int high)
{
if (low < high)
{
int pivot = partition(array, low, high);
QSort(array, low, pivot - 1);
QSort(array, pivot + 1, high);
}
}
void QuickSort(int array[], int len)
{
QSort(array, 0, len - 1);
}
int main(int argc, char *argv[])
{
int array[] = { 21,25,49,25,16,8 };
int len = sizeof(array) / sizeof(*array);
printf("快速排序前：");
println(array, len);
QuickSort(array, len);
printf("快速排序后：");
println(array, len);
system("pause");
return 0;
}
3.选择排序：简单选择排序、堆排列等
// 分类 -------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- O(n^2)
// 最优时间复杂度 ---- O(n^2)
// 平均时间复杂度 ---- O(n^2)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 不稳定
#include <stdio.h>
#include <stdlib.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void swap(int array[], int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
void SelectionSort(int array[], int len)
{
int i = 0;
int j = 0;
int k = -1; // k用来标记最小元素的位置
for (i = 0; i < len; i++)
{
k = i;
for (j = i; j < len; j++) // 最小值查找
{
if (array[j] < array[k])
{
k = j;
}
}
swap(array, i, k);
}
}
int main(int argc, char *argv[])
{
int array[] = { 21,25,49,25,16,8 };
int len = sizeof(array) / sizeof(*array);
printf("选择排序前：");
println(array, len);
SelectionSort(array, len);
printf("选择排序后：");
println(array, len);
system("pause");
return 0;
}
// 分类 -------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- O(nlogn)
// 最优时间复杂度 ---- O(nlogn)
// 平均时间复杂度 ---- O(nlogn)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 不稳定
#include <stdio.h>
#include <stdlib.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void swap(int array[], int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 重新调整堆
void Heapify(int array[], int i, int size) // 从\array[i]向下进行堆调整
{
int left_child = 2 * i + 1; // 左孩子索引
int right_child = 2 * i + 2; // 右孩子索引
int max = i; // 选出当前结点与其左右孩子三者之中的最大值
if (left_child < size && array[left_child] > array[max])
max = left_child;
if (right_child < size && array[right_child] > array[max])
max = right_child;
if (max != i)
{
swap(array, i, max); // 把当前结点和它的最大(直接)子节点进行交换
Heapify(array, max, size); // 递归调用，继续从当前结点向下进行堆调整
}
}
// 建堆，时间复杂度O(n)
int BuildHeap(int array[], int n)
{
int heap_size = n;
int i = 0;
// 从每一个非叶结点开始向下进行堆调整,有n个结点的完全二叉树，
// 最后一个分支结点的标号是n/2,数组下标从0开始，所以减去1
for (i = heap_size / 2 - 1; i >= 0; i--)
Heapify(array, i, heap_size);
return heap_size;
}
void HeapSort(int array[], int n)
{
int heap_size = BuildHeap(array, n); // 建立一个最大堆
while (heap_size > 1) // 堆（无序区）元素个数大于1，未完成排序
{
// 将堆顶元素与堆的最后一个元素互换，并从堆中去掉最后一个元素
// 此处交换操作很有可能把后面元素的稳定性打乱，所以堆排序是不稳定的排序算法
swap(array, 0, --heap_size);
Heapify(array, 0, heap_size); // 从新的堆顶元素开始向下进行堆调整，时间复杂度O(logn)
}
}
int main(int argc, char *argv[])
{
int array[] = { 5,4,3,2,1 };
int len = sizeof(array) / sizeof(*array);
printf("堆排序前：");
println(array, len);
HeapSort(array, len);
printf("堆排序后：");
println(array, len);
system("pause");
return 0;
}
4.归并排序：
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- O(nlogn)
// 最优时间复杂度 ---- O(nlogn)
// 平均时间复杂度 ---- O(nlogn)
// 所需辅助空间 ------ O(n)
// 稳定性 ------------ 稳定
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
void println(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Merge(int src[], int des[], int low, int mid, int high)
{
int i = low;
int j = mid + 1;
int k = low;
while ((i <= mid) && (j <= high)) // 将较小元素复制到新序列
{
if (src[i] < src[j])
{
des[k++] = src[i++];
}
else
{
des[k++] = src[j++];
}
}
// 剩余部分照抄到新序列中
while (i <= mid)
{
des[k++] = src[i++];
}
while (j <= high)
{
des[k++] = src[j++];
}
}
// 将src里面的元素进行排序，复制到des里面
void MSort(int src[], int des[], int low, int high, int max)
{
if (low == high)
{
des[low] = src[low];
}
else
{
int mid = (low + high) / 2;
int *space = (int *)malloc(sizeof(int)*max); // 申请辅助空间
if (space != NULL)
{
MSort(src, space, low, mid, max);
MSort(src, space, mid + 1, high, max);
Merge(space, des, low, mid, high);
}
free(space);
}
}
void MergeSort(int array[], int len) // O(nlogn)
{
MSort(array, array, 0, len - 1, len);
}
int main(int argc, char *argv[])
{
int array[] = { 21,25,49,25,16,8 };
int len = sizeof(array) / sizeof(*array);
printf("归并排序前：");
println(array, len);
MergeSort(array, len);
printf("归并排序后：");
println(array, len);
system("pause");
return 0;
}
5.基数排序：
#include<stdio.h>
#include<string.h>
#define N 10 //数组长度
#define D 10 //最大位数
int GetDigit(int M, int i) //取整数M的第i位数
{
while(i > 1)
{
M /= 10;
i--;
}
return M % 10;
}
void RadixSort(int num[], int len)
{
int i, j, k, l, digit;
int allot[10][N]; //《分配数组》
memset(allot, 0, sizeof(allot));//初始化《分配数组》
for(i = 1; i <= D; i++)
{
//分配相应位数的数据，并存入《分配数组》
for(j = 0; j < len; j++)
{
digit = GetDigit(num[j], i);
k = 0;
while(allot[digit][k])
k++;
allot[digit][k] = num[j];
}
//将《分配数组》的数据依次收集到原数组中
l = 0;
for(j = 0; j < 10; j++)
{
k = 0;
while(allot[j][k] > 0)
{
num[l++] = allot[j][k];
k++;
}
}
//每次分配，收集后初始化《分配数组》，用于下一位数的分配和收集
memset(allot, 0, sizeof(allot));
}
}
int main()
{
int num[N] = {52, 20, 4, 10, 17, 39, 8, 300, 60, 81};
RadixSort(num, N);
for(int i = 0; i < N; i++)
printf("%d ", num[i]);
printf("\n");
return 0;
}
参考：
https://blog.csdn.net/qq_22847457/article/details/98070178
https://blog.csdn.net/qq_22847457/article/details/98173154
排序算法之堆排序
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
