【大话数据结构】几种排序算法
来源:互联网 发布:达克宁 兰美抒 知乎 编辑:程序博客网 时间:2024/05/16 00:47
这篇笔记主要是写写这些常见的排序算法。
冒泡排序
思想:两两比较相邻记录的关键字,反序则交换,直到没有反序为止。
#include <stdio.h>/*交换int型数组L中下标i和j的值*/void swap(int *L, int i, int j){int temp = L[i];L[i] = L[j];L[j] = temp;}void BubbleSort(int *L){int i, j;int len = sizeof(L) / sizeof(int);for (i = 0; i < len; i++){ /*i前面是排好序的*/for (j = len-1; j > i; j--) /*从后向前比,小的在前,大的在后*/{if (L[j] < L[j-1]){swap(L, j, j-1);}}}}
分析:最好的情况比较n-1次,时间复杂度O(n);最坏的情况比较n(n-1)/2次,时间复杂度O(n2)。
选择排序
思想:每趟在n-i+1次比较里,选择关键字最小的记录与第i个记录交换。
void SelectionSort(int *L){int i, j, min;int len = sizeof(L)/sizeof(int);for (i = 0; i < len; i++){min = i;for (j = i + 1; j < len; j++) /*i+1前面是排好序的*/{if (L[j] < L[min]){min = j;}}if (i != min)swap(L, i, min);}}
分析:比较次数,最好最坏都是n(n-1)/2次;交换次数,最好0次,最坏n-1次,综合起来时间复杂度是O(n2)。性能比冒泡好一点。
插入排序
思想:将一个记录插入到已经排好序的有序表中,表记录数加1。
void InsertiontSort(int *L){int i, j;int len = sizeof(L)/sizeof(int);for (i = 0; i < len-1; i++){int temp = L[i+1];for (j = i; j >= 0; j--) /*i+1前面就是排好序的*/{if (temp < L[j])L[j+1] = L[j]; /*后移*/}L[j] = temp; /*插入到正确的位置*/}}
分析:如果记录顺序是随机的,平均比较和移动的次数为n2/4,时间复杂度是O(n2)。性能比冒泡和选择要好一点。
希尔排序
思想:(也称缩小增量排序)给出一个增量increment,让相隔增量的记录跳跃式的移动,这增加了效率。最后的increment必须为1。
void ShellSort(int *L){int i, j,increment;int len = sizeof(L) / sizeof(int);for (increment = len / 2; increment >= 1; increment = increment / 2) /*定增量,并不断减小*/{for (i = increment; i < len; i++){if (L[i] < L[i - increment])swap(L, L[i], L[i - increment]);}} }
分析:确定增量的取值也是一个问题,大量实验证明,其平均时间复杂度O(n3/2)。希尔排序的出现突破了慢速排序(O(n2))的时代,更为高效的算法陆续出现。
堆排序
思想:堆是一种特殊的完全二叉树,它只有两种:每个结点大于等于它子结点的是大顶堆,小于等于它子结点的是小顶堆。堆排序就是通过构造堆来排序。将待排序数组构成一个大顶堆,把堆顶的根结点(最大值)移走,也就是和堆数组末尾交换,最大值就到了数组最后,再将剩下n-1个数重新构造成一个堆,找到n个元素中第二大值,重复执行。
关键:1如何将原始无序数组构建成一个堆
2输出堆顶元素后,如何调整剩余元素成为新堆
void swap(int *L, int i, int j){int temp = L[i];L[i] = L[j];L[j] = temp;}void HeapSort(int *L){int i;int len = sizeof(L) / sizeof(int);for (i = len / 2; i > 0; i--) //完全二叉树调成堆,并不需要len次,只需要交换反了的结点HeapAdjust(L, i, len);for (i = len-1; i > 0; i--){swap(L, 0, i); //堆顶结点和序列最后一个元素交换HeapAdjust(L, 0, i - 1); //将L[0...i-1]重新调整为大顶堆}}void HeapAdjust(int *L, int i, int j){int temp, k;temp = L[i];for (k = 2 * i; k <= j; k *= 2){if (k < j && L[k] < L[k + 1])++j;//k为关键字中较大记录的下标if (temp >= L[k])break;L[i] = L[k];i = k;}L[i] = temp;}
分析:能提高效率是因为充分利用了二叉树深度是 ⌊log2n⌋+1 的性质。构建堆的时间复杂度O(n),重建堆的时间复杂度是O(nlogn),所以总的时间复杂度是O(nlogn)。
归并排序
思想:将一个无序的数组,两两合并排序后再合并,最终得到有序数组。
#include <stdio.h>#include <stdlib.h>void MergeSort(int *L, int p, int r) //用归并的方式把数组不断二分{int q;if (p < r){q = (int)((p + r) / 2);MergeSort(L, p, q);MergeSort(L, q + 1, r);Merge(L, p, q, r);}}void Merge(int *L, int p, int q, int r) //合并函数{int i, j, k;int n1 = q - p + 1;int n2 = r - q + 1;int *left = (int *)malloc(sizeof(int)*n1);int *right = (int *)malloc(sizeof(int)*n2);for (i = 0; i < n1; i++) //对左数组赋值 left[i] = L[p + i];for (j = 0; j < n2; j++) //对右数组赋值 right[j] = L[q + 1 + j];i = j = 0;k = p; //k从L的起点开始while (i < n1 && j < n2) //将左右数组的元素两两比较,并合并到L {if (left[i] <= right[j])L[k++] = left[i++];elseL[k++] = right[j++];}for (; i < n1; i++) //如果左数组有元素剩余,则将剩余元素合并到LL[k++] = left[i];for (; j < n2; j++) //如果右数组有元素剩余,则将剩余元素合并到LL[k++] = right[j];}
分析:结构类似于颠倒的完全二叉树,整个归并排序需要进行 ⌈log2n⌉ 次,则总的时间复杂度是O(nlogn);但因为过程中需要与原数组同大小的空间存放递归结果,并且要递归深度是 log2n 的栈空间,则空间复杂度是O(n+logn)。它是一种比较占内存、但效率高且稳定的排序算法。
快速排序
思想:选取一个关键字(开始一般key=SqList[0]),找到它在数组中的位置,也就是从两端向中间扫描数组,通过交换把<key的放前面,>key的放后面;一次遍历终了相当于把整个数组partition成两部分(被key分开,未必平均分),递归每部分。
#include<iostream>void QuickSort(int *A, int p, int r){int x = A[p];int i = p;int j = r;if (p < r){while (i < j){for (; A[j] >= x && j > i; j--){}for (; A[i] <= x && i < j; i++){}if (i < j){int temp = A[i];A[i] = A[j];A[j] = temp;}else{int temp = A[j];A[j] = x;A[p] = temp;}}QuickSort(A, p, j - 1);QuickSort(A, j + 1, r);}}还有一种比较优美的写法,
void QuickSort(int A[], int left, int right){if (left >= right)return;int i = left;int j = right;int key = A[left];while (i < j){while (i < j && key <= A[j])j--;A[i] = A[j];while (i < j && key >= A[i])i++;A[j] = A[i];}A[i] = key;QuickSort(A, left, i - 1);QuickSort(A, i + 1, right);}
分析:平均时间复杂度是O(nlogn),少数最差情况虽然也能达到O(n2);因为递归使用栈空间,平均情况的空间复杂度是O(logn)。因为关键字的比较和交换是跳跃的,所以它是种不稳定的方法。
- 【大话数据结构】几种排序算法
- 【数据结构】几种常见的排序算法
- 数据结构中的几种排序算法
- 数据结构:几种排序算法的介绍。
- 数据结构几种常用排序算法总结
- 数据结构之排序算法实现(选自大话数据结构)
- 【数据结构】几种排序
- 大话数据结构--排序
- 大话数据结构7 - 排序
- 《大话数据结构》常见排序算法总结(一)
- 【大话数据结构&算法】冒泡排序(Java/C实现源码)
- 【大话数据结构&算法】希尔排序(Java/C实现源码)
- 【大话数据结构&算法】归并排序(Java/C实现源码)
- 数据结构与算法--几种排序的实现(C++)
- 数据结构与算法 :提到的几种排序
- 【大话数据结构&算法】哈夫曼树
- 大话数据结构笔记-算法
- 大话排序算法
- 人人都可以做深度学习应用:入门篇(下)
- 回来看见哈喽快结婚了速度快干活了卡机
- Python流程控制语句->While循环
- 软技能——代码之外的生存指南
- graphql学习(四)GraphQL和SpringMVC 的整合
- 【大话数据结构】几种排序算法
- SQL常用基础语句-增删改查
- three.js中常用的光源详解
- [ML笔记]监督学习与无监督学习
- 威慑力京哈赶快睡觉读后感卡号的
- 使用本机连接虚拟机的oracle步骤
- 《大话数据结构》学习笔记--chapter 3
- 剑指offer | 训练题63:滑动窗口的最大值
- XSS web安全浅析