内部排序
插入排序
直接插入排序
//插入排序：每次将一个待排序的的记录按其关键字大小插入到前面已排好的子序列中，直到全部记录插入完成。
//直接插入排序
void InsetrSort(int A[], int n)
{
int i, j, temp;
for (i = 1; i < n;i++) //将各元素插入已排好的序的序列中
{
if (A[i] < A[i - 1]) //若A[i]关键字小于前驱
{
temp = A[i]; //用temp暂存
for (j = i - 1; j >= 0 && A[j] > temp; --j) //检查前面已经排好序的元素
A[j + 1] = A[j]; //所有大于temp的元素向后挪位
A[j + 1] = temp; //复制到插入位置
}
}
}
//直接插入排序(带哨兵)"将A[0]代替实现temp的缓存作用"
void InsertSort(int A[],int n) {
int i, j;
for (i = 2; i <= n; i++) {
if (A[i] < A[i - 1]) {
A[0] = A[i];
for (j = i - 1; j >= 0 && A[j] > A[0]; --j)
A[j + 1] = A[j];
A[j + 1] = A[0];
}
}
}
空间复杂度：O(1)
最好时间复杂度—— O(n)
最坏时间复杂度——O(n²)
平均时间复杂度：O(n²)
稳定性：稳定
折半插入排序
先⽤折半查找，找到应该插⼊的位置，再移动元素。
//折半插入排序
void InsertSort(int A[], int n) {
int i, j, low, high, mid;
for (i = 2; i < n; i++) { //依次将A[2]～A[n]插入到前面的已排序序列
A[0] = A[i]; //将A[i]暂存到A[0]
low = 1; //设置折半查找范围
high = i - 1;
while (low <= high) { //折半查找(默认递增有序)
mid = (low + high) / 2; //取中间点
if (A[mid] > A[0])
high = mid - 1; //查找左半子表
else
low = mid + 1; //查找右半子表
}
for (j = i - 1; j >= high + 1; --j)
A[j + 1] = A[j]; //统一后移元素，空出插入位置
A[high + 1] = A[0]; //插入操作
}
}空间复杂度：O(1)
最好时间复杂度—— O(n)
最坏时间复杂度——O(n²)
平均时间复杂度：O(n²)
稳定性：稳定
希尔排序
先将待排序表分割成若⼲形如 L[i, i + d, i + 2d,…, i + kd] 的“特殊”⼦表，对各个⼦表 分别进⾏直接插⼊排序。缩⼩增量d，重复上述过程，直到d=1为⽌。
//希儿排序
void InsertSort(int A[], int n) {
int d, i, j;
//A[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已到
for(d=n/2;d>=1;d=d/2) //步长变化
for(i=d+1;i<=n;++i)
if (A[i] < A[i - d]) { //需将A[i]插入有序增量子表
A[0] = A[j]; //暂存在A[0]
for (j = i - d; j > 0 && A[0] < A[j]; j -= d)
A[j + d] = A[j]; //记录后移
A[j + d] = A[0]; //插入
}//if
}空间复杂度：O(1)
时间复杂度：未知，但优于直接插入排序
稳定性：不稳定
适⽤性：仅适⽤于顺序表。
交换排序
冒泡排序
从后往前（或从前往后）两两⽐较相邻元素的值，若为逆序（即A[i-1]>A[i]），则交换它们，直到序 列⽐较完。
//交换
void Swap(int a, int b) {
int temp = a;
a = b;
b = temp;
}
//冒泡排序
void BubbleSort(int A[], int n) {
for (int i = 0; i < n-1; i++) {
bool flag = false; //表示本趟冒泡是否发生交换的标志
for (int j = n - 1; j > i; j--) { //一趟冒泡过程
if (A[j - 1] > A[j]) { //若为逆序
Swap(A[j - 1], A[j]); //交换
flag = true;
}
if (flag == false)
return; // 本趟遍历后没有发生交换，说明表已经有序
}
}
}空间复杂度：O(1)
时间复杂度：最好O(n) 有序
最差O(n²) 逆序
平均O(n²)
稳定性：稳定
适⽤性：顺序表、链表。
快速排序
更⼩的元素都交换到左边 更⼤的元素都交换到右边
//用第一个元素将待排序序列划分成左右两个部分
int Partition(int A[], int low, int high) {
int pivot = A[low]; //第一个元素作为枢轴
while (low < high) { //用Low、high搜索枢轴的最终位置
while (low < high && A[high] >= pivot)
--high;
A[low] = A[high];//比枢轴小的元素移动到左端
while (low < high && A[low] <= pivot)
++low;
A[high] = A[low];//比枢轴大的元素移动到右端
}
A[low] = pivot; //枢轴元素存放到最终位置
return low; //返回存放枢轴的最终位置
}
//快速排序
void QuickSort(int A[], int low, int high) {
if (low < high) {//递归跳出的条件
int pivotpos = Partition(A, low, high); //划分
QuickSort(A, low, pivotpos - 1);//划分左子表
QuickSort(A, pivotpos + 1, high); //划分右子表
}
}
空间复杂度：最好O(n)
最差O()
时间复杂度：最好O(n²) 每次划分很平均
最差O() 原本正序或逆序
平均O()
稳定性：不稳定
选择排序
每⼀趟在待排序元素中选取关键字最⼩（或最⼤）的元素加⼊有序⼦序列。
简单选择排序
每⼀趟在待排序元素中选取关键字最⼩的元素加⼊有序⼦序列
//交换
void Swap(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
//简单选择排序
void SelectSort(int A[], int n) {
for (int i = 0; i < n - 1; i++) { //一共进行n-1趟
int min = i; //记录最小元素位置
for (int j = i + 1; j < n; j++)//在A[i...n-1]中选择最小的元素
if (A[j] < A[min])
min = j;//更新最小元素位置
if (min != i)
Swap(A[i], A[min]);//封装的swap()函数共移动元素3次
}
}空间复杂度：O(1)
时间复杂度=O(n²)
稳定性：不稳定
适⽤性：既可以⽤于顺序表，也可⽤于链表
堆排序
每⼀趟将堆顶元素加⼊有序⼦序列 （与待排序序列中的最后⼀个元素交换）并将待排序元素序列再次调整为⼤根堆 （⼩元素不断“下坠”）
//建立大根堆
void BuildMaxHeap(int A[], int len) {
for (int i = len / 2; i > 0; i--)//从后往前调整所有非终端结点
HeadAdjust(A, i, len);
}
//将以 k为根的子树调整为大根堆
void HeadAdjust(int A[], int k, int len) {
A[0] = A[k]; //A[0]暂存子树的根结点
for (int i = 2 * k; i <= len; i *= 2) { //沿key较大的子结点向下筛选
if (i < len && A[i] < A[i + 1])
i++; //取key较大的子结点的下标
if (A[0] >= A[i])
break; //筛选结束
else {
A[k] = A[i]; //将A[i]调整到双亲结点上//修改k值，以便继续向下筛选
k = i;
}
}
A[k] = A[0]; //被筛选结点的值放入最终位置
}
//交换
void Swap(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
//堆排序的完整逻辑
void HeapSort(int A[], int len) {
BuildMaxHeap(A, len); //初始建堆
for (int i = len; i > 1; i--) { //n-1趟的交换和建堆过程
Swap(A[i], A[1]); //堆顶元素和堆底元素交换
HeadAdjust(A, 1, i - 1); //把剩余的待排序元素整理成堆
}
}
空间复杂度：O(1)
时间复杂度: 建堆O(n)+排序O()=总时间复杂度O(
)
稳定性：不稳定
归并排序和基数排序
归并排序
空间复杂度：O(n)
时间复杂度: O()
稳定性：稳定
基数排序
① 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。
② 从最低位开始，依次进行一次排序。
③ 这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
int Maxbit(int data[], int n) //辅助函数，求数据的最大位数
{
int maxData = data[0]; // 最大数
// 先求出最大数，再求其位数，这样有原先依次每个数判断其位数，稍微优化点。
for (int i = 1; i < n; ++i)
{
if (maxData < data[i])
maxData = data[i];
}
int d = 1;
int p = 10;
while (maxData >= p)
{
//p *= 10;
maxData /= 10;
++d;
}
return d;
}
void radixsort(int data[], int n) //基数排序
{
int d = Maxbit(data, n);
int *tmp = new int[n];
int *count = new int[10]; //计数器
int i, j, k;
int radix = 1;
for(i = 1; i <= d; i++) //进行d次排序
{
for(j = 0; j < 10; j++)
count[j] = 0; //每次分配前清空计数器
for(j = 0; j < n; j++)
{
k = (data[j] / radix) % 10; //统计每个桶中的记录数
count[k]++;
}
for(j = 1; j < 10; j++)
count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
for(j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中
{
k = (data[j] / radix) % 10;
tmp[count[k] - 1] = data[j];
count[k]--;
}
for(j = 0; j < n; j++) //将临时数组的内容复制到data中
data[j] = tmp[j];
radix = radix * 10;
}
delete []tmp;
delete []count;
}按照各个 关键字位 权重递增的次序 (如：个、十、百)，做 d 趟“分配”和“收集”，若当前处理的 关键字位 可能取得r个值，则需要建立r个队列
空间复杂度：O(r)
时间复杂度: O(d(r+n))
稳定性：稳定
外部排序
参考外部排序
https://blog.csdn.net/qq_44629109/article/details/119779751
扫一扫
897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
