排序算法总结

排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序； O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。 名词解释： n：数据规模 k："桶"的个数 In-place：占用常数内存，不占用额外内存 Out-place：占用额外内存 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 1.1冒泡排序 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

排序算法总结 各种排序算法的图解及思想 1.冒泡排序 2.选择排序 3.插入排序 4.希尔排序 5.归并排序 6.快速排序 7.基数排序 各种排序算法复杂度 各种排序算法的图解及思想 1.冒泡排序 1.图解： 2.也就是说如果前一个与后一个逆序则交换， 2.选择排序 1.图解 2.从未经排序的元素中选择出需要的最大数或者最小数放到a[0]位置,再是a[1]… 3.插入排序 1.图解 2.第一个元素直接插入，从第二个元素开始，需要插入的元素与已经插入的元素比较，找到一个合适的位置插入， 4.希尔排序 1.图解 5.归并排序 1.图解 2.采用分治法，将子序列排序，最后合并排序 6.快速排序 1.图解 2.选择第一个数或者其他数作为基准数，将剩余元素与基准数比较，小的放左边部分，大的放右边部分，再在左右两遍部分中各选出一个基准数，继续比较，直到每个左右部分子序列都只有一个数为止。 7.基数排序 1.图解 2. 先按照个位对所有数值分类，个位相同的放一个桶中，再循环遍历每个桶中的数据取出放到原来的数组中，接下来将刚刚获得的新数组继续按照十位分类… 各种排序算法复杂度 来源： CSDN 作者： weixin_43723078 链接： https://blog.csdn.net/weixin_43723078/article/details/103994545

10种排序算法总结 排序算法有很多，所以在特定情景中使用哪一种算法很重要。为了选择合适的算法，可以按照建议的顺序考虑以下标准： （1）执行时间 （2）存储空间 （3） 编程 工作 对于数据量较小的情形，（1）（2）差别不大，主要考虑（3）；而对于数据量大的，（1）为首要。 主要排序法有： 一、冒泡（Bubble）排序——相邻交换 二、选择排序——每次最小/大排在相应的位置 三、插入排序——将下一个插入已排好的序列中 四、壳（Shell）排序——缩小增量 五、归并排序 六、快速排序 七、堆排序 八、拓扑排序 九、锦标赛排序 十、基数排序 一、冒泡（Bubble）排序 void BubbleSortArray() { for(int i=1;i<n;i++) { for(int j=0;i<n-i;j++) { if(a[j]>a[j+1])//比较交换相邻元素 { int temp; temp=a[j];　　　　　　　　　　 a[j]=a[j+1]; 　　　　　　　　　　　a[j+1]=temp; } } } } 效率 O（n²）,适用于排序小列表。 二、选择排序 void SelectSortArray() { int min_index; for(int i=0;i<n-1;i++) { min_index=i; for(int j=i+1;j<n;j++)//每次扫描选择最小项

一、插入排序：稳定，时间复杂度O(n^2) 想象你在打扑克牌，一開始左手是空的，接着右手開始从桌上摸牌，并将其插入到左手的一把牌中的正确位置上。为了找到这个正确位置，我们须要从右到左将它与手中的牌比較，直到找到合适的位置插入。整个过程的特点是，左手的牌是排好序的了。 详见： 插入排序 二、选择排序：不稳定，时间复杂度O(n^2) 每趟从未排序部分选出最小的元素。然后通过交换将其加入到已排序部分中。 详见： 选择排序 三、冒泡排序：稳定，时间复杂度O(n^2) 将待排序的元素看作是竖着排列的“气泡”。较小的元素比較轻。从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。 假设发现两个相邻元素的顺序不正确。即“轻”的元素在以下，就交换它们的位置。显然。处理一遍之后，“最轻”的元素就浮到了最高位置；处理两遍之后。“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。 一般地。第i遍处理时，不必检查第i高位置以上的元素。由于经过前面i-1遍的处理，它们已正确地排好序。 详见： 冒泡排序 四、归并排序：稳定。时间复杂度 O(nlog n)，空间O(n) 分解：将n个元素分成各含n/2个元素的子序列。 解决：用归并排序法对两个子序列递归地排序。 合并

排序算法知识点总结 时间复杂度比较 排序算法名称 时间复杂度 冒泡排序（比较排序算法） O（n*n） 选择排序（比较排序算法） O（n*n） 插入排序（比较排序算法） O（n*n） 希尔排序（比较排序算法） O（nlog2n） 归并排序（比较排序算法） O（nlogn） 堆排序（比较排序算法） O(logn) 快速排序 O（nlogn）最坏情况O（n*n） 树排序 O（nlogn）最坏情况O（n*n） 计数排序(线性排序算法) O(n) 桶排序（线性排序算法） O(n) 基数排序 （线性排序算法） O(n) 2. 空间复杂度比较 排序算法名称 空间复杂度 冒泡排序（比较排序算法） 1 选择排序（比较排序算法） 1 插入排序（比较排序算法） 1 希尔排序（比较排序算法） 1 归并排序（比较排序算法） O（n） 堆排序（比较排序算法） 1 快速排序 O（logn） 树排序 O（n） 3. 是否为稳定排序 排序算法名称 是否稳定 冒泡排序（比较排序算法） 是 选择排序（比较排序算法） 否 插入排序（比较排序算法） 是 希尔排序（比较排序算法） 否 归并排序（比较排序算法） 是 堆排序（比较排序算法） 否 快速排序 不确定 树排序 不确定 4.牛客题型总结 未完待续 来源： CSDN 作者： coder-peiqi 链接： https://blog.csdn.net/weixin

1.最基础的排序算法 冒泡排序 思想：每次使用交换的方式将剩余元素中较大的元素放到一端，直到剩余元素为0的时候排序结束。 # include <stdio.h> int main ( ) { int a [ 5 ] = { 1 , 3 , 5 , 10 , 7 } ; printf ( "排序前：" ) ; for ( int i = 0 ; i < 5 ; i ++ ) printf ( "%d " , a [ i ] ) ; int temp = 0 ; //每次循环将最大值交换到数组最右端 for ( int i = 0 ; i < 5 ; i ++ ) { for ( int j = 0 ; j < 5 - i ; j ++ ) { //每遍历一次数组，可以确定当前剩余元素中的最大值 if ( a [ j ] > a [ j + 1 ] ) { temp = a [ j ] ; a [ j ] = a [ j + 1 ] ; a [ j + 1 ] = temp ; } } } printf ( "\n排序后：" ) ; for ( int i = 0 ; i < 5 ; i ++ ) printf ( "%d " , a [ i ] ) ; } 排序结果： 来源： CSDN 作者： 没有胡子的猫 链接： https://blog.csdn.net/qq_39827677

算法总结之选择排序(java实现） 选择排序是一种简单直观的排序算法，他也是一种交换排序算法，和冒泡算法有一定的相似程度，可以认为选择排序是冒泡排序的一种改进。 算法描叙（以顺序为列） 在未排序的数组序列中找到最小的数据元素，存放在数组序列的起始位置。 从剩余未排序的数组元素中继续寻找最小的数据元素，然后存放到已排序序列的末尾 重复第二步，直到数组所有元素均排序完毕 算法实现 public static void selectSort ( int [ ] arr ) { int temp , min = 0 ; for ( int i = 0 ; i < arr . length - 1 ; i ++ ) { min = i ; //循环查找最小值 for ( int j = i + 1 ; j < arr . length - 1 ; j ++ ) { if ( arr [ min ] > arr [ j ] ) min = j ; } if ( min != i ) { temp = arr [ i ] ; arr [ i ] = arr [ min ] ; arr [ min ] = temp ; } } } 稳定性 当选择排序用数组实现时，是不稳定的，但是如果用链表实现选择排序，则可以达到稳定，因为实际只是发生位置了变换，并没有发生位置交换，所以相同的数字不会交换位置。

交换排序（冒泡排序、快速排序） 插入排序（直接插入排序、希尔排序）、 选择排序（直接选择、堆排序） 归并排序 基排序 1.冒泡排序 时间复杂度：最优情况下是O（n），最坏情况和平均情况是O（n2） 空间复杂度：O(1) 稳定 算法实现是 #include<stdio.h> void main() { int a[6]={2,1,5,3,6,7}; int temp=0; int i=0; int j=0; int m=0; for(;i<6;i++) for(j=i;j<6-i;j++) { if(a[j+1]<a[j]) { temp=a[j+1]; a[j+1]=a[j]; a[j]=temp; } } for(;m<6;m++) { printf("%d ",a[m]); } } 从小到大排序 结果是1 2 3 5 6 7 2 快速排序 时间复杂度：最好情况是O(nlogn)、最坏情况是O(n2)、平均情况是O(nlogn) 空间复杂度：O(nlogn) 不稳定 #include<stdio.h> void sort(int *a, int left, int right) { int i = left; int j = right; int key = a[left]; int m=0; if(left >= right)/

1、冒泡排序 //冒泡排序 void bubbleSort(int A[], int n) { bool flag = false; for (int i = n - 1; i > 0; i--) { //注意i,j的终止条件 for (int j = 0; j < i; j++) { if (A[j]>A[j + 1])swap(A[j], A[j + 1]); flag = true; } if (flag == false)return; } } View Code （上面代码有误，交换和改变flag值应有大括号） 最差时间复杂度 O(n²) 记录是反序的，需要n-1次扫描，每趟扫描进行n-i次比较，每次比较都要移动3次 最优时间复杂度 O(n) 记录是正序的，一趟扫描即可完成，比较n-1次 平均时间复杂度 O(n²) 虽然冒泡排序不一定进行n-1趟，但记录移动次数多，故平均时间性能比直接插入排序差 最差空间复杂度 O(1) 优点：稳定； 缺点：慢，每次只能移动相邻两个数据 2、插入排序 //插入排序 void insertSort(int A[], int n) { for (int i = 1; i < n; i++) { //注意j从i-1开始 for (int j = i - 1; j >= 0;j--) if (A[i] < A[j]) swap(A[i], A[j

最经典的算法莫过于选择排序和冒泡排序： 在总结之前先看了如下一篇博客： https://blog.csdn.net/chen13579867831/article/details/78790853 Java中的选择排序和冒泡排序思想及代码实现 博主对这两种排序方法，介绍得比较清楚，不过这里我扣扣其中的细节并加上我自己的一些理解。 选择排序（降序）： // i 控制排序次数，取值从0到array.length-2，最后一个元素不用取出 for(int i = 0 ;i<array.length-1;i++) { /* j 控制每次排序比较次数，每次比较从取出来要比较的值后面第一个元素 开始，到该数组最后一个元素比较结束，所以每次比较j从i+1开始，到 array.length-1结束*/ for(int j = i+1;j<array.length;j++) { if(array[i]<array[j]) { int temp = array[i]; array[i] = array[j]; array[j] = temp; count++; } } } System.out.println(Arrays.toString(array)); 冒泡排序（降序）： public class BubbleSort { public static void main(String[]