排序算法总结

直插排序 void insertsort ( int * a , int n ) //升序 { for ( int i = 1 , j ; i < n ; i ++ ) { int tem = a [ i ] ; for ( j = i - 1 ; j >= 0 ; j -- ) if ( a [ j ] > tem ) a [ j + 1 ] = a [ j ] ; else break ; a [ j + 1 ] = tem ; //print(a, n); } } 希尔排序 void shellsort ( int * a , int n ) //降序 { for ( int gap = n / 2 ; gap >= 1 ; gap / = 2 ) { for ( int i = gap , j ; i < n ; i ++ ) { int tem = a [ i ] ; for ( j = i - gap ; j >= 0 ; j - = gap ) if ( a [ j ] < tem ) a [ j + gap ] = a [ j ] ; else break ; a [ j + gap ] = tem ; } //print(a, n); } } 冒泡排序 void bubblesort ( int * a , int n ) { int count = 0 ; /

选择排序 选择排序是一个非常简单且直观的算法，顾名思义，就是每次遍历数组，将其最小或最大（以下举例都是从小到大排序）的以依次放入已排好序的数组，再重复此操作。 动画演示 动画过程解释 第一步遍历无序数组找到最小的数是2 将其与第一个数组交换（此时0-1即为已排序数组） 第二步再次遍历无序数组，找到最小数字是3 ，与第二个数字交换（此时0-2位已排序数组） 以此类推 最终得到一个0-n-1的排序数组 代码展示 因为最近我在看Go语言，顺便复习一下算法，所以就用贴Go语言代码了，Go和C/C+语言差不多，应该也能看懂 //选择排序 for i := 0 ; i < 10 ; i ++ { var min , index int = n [ i ] , i for j := i ; j < 10 ; j ++ { if min > n [ j ] { min = n [ j ] index = j } } min = n [ i ] n [ i ] = n [ index ] n n [ index ] = min } 插入排序 插入排序就像是玩扑克牌，假设你有5张牌3 4 6 7 5，如何才能让它好看一点呢，是不是把5插入到4 和6中间去，也就是插入位置的前一位比它小，后一位比它大。用算法分析就是，假设从第二个数开始，默认认为0-1为已排序数组（只有一个数当然排序啦）

排序 插入排序 直接插入排序 基本思想： 在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 public void insertSort ( int [ ] a ) { System . out . println ( "\n排序前数据：" ) ; for ( int i = 0 ; i < a . length ; i ++ ) { System . out . print ( " " + a [ i ] ) ; } // 数组长度 int length = a . length ; // 要插入的数 int insertNum ; // 插入的次数 for ( int i = 1 ; i < length ; i ++ ) { // 要插入的数 insertNum = a [ i ] ; // 已经排序好的序列元素个数 int j = i - 1 ; // 序列从后到前循环，将大于insertNum的数向后移动一格 while ( j >= 0 && a [ j ] > insertNum ) { // 元素移动一格 a [ j + 1 ] = a [ j ] ; j -- ; } // 将需要插入的数放在要插入的位置。 a [ j + 1 ] =

排序算法总结 冒泡排序 选择排序 插入排序 归并排序 快速排序 堆排序 冒泡排序 public void sort ( int [ ] nums ) { int i , j , min , t ; for ( i = 0 ; i < nums . length ; i ++ ) { min = i ; for ( j = i + 1 ; j < nums . length ; j ++ ) { if ( nums [ j ] < nums [ min ] ) { min = j ; } } t = nums [ min ] ; nums [ min ] = nums [ i ] ; nums [ i ] = t ; } } 无论最好还是最坏情况下时间复杂度都是 O ( N 2 ) O(N^2) O ( N 2 ) ，是一种比较低效率的排序方法。 选择排序 插入排序 归并排序 归并排序的思路是一半一半排序，假设左右两边都已经是有序的了，那么再按大小顺序插入一个新的数组里即可，需要 N N N 次操作，而利用递归来使左右两边达到有序需要 l o g 2 n log_2n l o g 2 ​ n 次，因此总的时间复杂度是 O ( N l o g N ) O(NlogN) O ( N l o g N ) ，又因为需要一个辅助的数组，空间复杂度是 O ( N ) O(N) O ( N ) 。

原创不易，尊重原创，本文转载于 Nim的辙迹 的博文，博文地址：http://blog.csdn.net/codernim/article/details/54312616 概述 排序的分类：内部排序和外部排序 内部排序：数据记录在内存中进行排序 外部排序：因排序的数据量大，需要内存和外存结合使用进行排序 这里总结的八大排序是属于内部排序： 当n比较大的时候， 应采用时间复杂度为（ nlog 2 n ）的排序 算法 ：快速排序、堆排序或归并排序。 其中，快速排序是目前基于比较的内部排序中被认为最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。 ——————————————————————————————————————————————————————————————————————— 插入排序——直接插入排序（ Straight Insertion Sort ） 基本思想： 将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。 即：先将序列的第1个记录看成一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。 要点：设立哨兵，用于临时存储和判断数组边界 直接插入排序示例： 插入排序是稳定的 ，因为如果一个带插入的元素和已插入元素相等，那么待插入元素将放在相等元素的后边，所以，相等元素的前后顺序没有改变。 算法实现： [cpp]

算法之排序算法总结 | Carrie博客 全部 全部 博客 友链 关于 ps:这里的排序都是从小到大进行排列。 冒泡排序 算法思想:从第一个数开始，将两个相邻的数进行比较，如果前一个数大于后一个数，则互换位置，否则保持不变。这样比较一趟，可以把最大的数放在末尾(根据循环的趟数决定)。依次循环，直到排序完成。 时间复杂度:O(n^2) 大专栏 算法之排序算法总结 li>空间复杂度:O(1) 选择排序 算法思想:从待排序的数字中找出最小的数，放在排序数字的最开始，之后依次在未排序的数字中选出最小的数放在已经排序的数字的末尾。 时间复杂度:O(n^2) 空间复杂度:O(1) 快速排序 算法思想:【i表示数组开始下标，j表示数组最后一个元素的下标】可以依赖递归来实现。选取一个基数（可以选取数组的第一个数作为基数），从最后一个数开始遍历，如果小于基数则将该数放在前面（a[i]=a[j,i++)；如果大于基数则将该数放在后面(a[j]=a[i],j++)；直到i==j，循环结束。之后，将开始下标置为0，结束下标置为i-1；开始下标置为i+1,结束下标置为数组长度-1,来实现递归操作。 时间复杂度:O(nlogn) 空间复杂度:O(1) 基数排序 算法思想:首先，决定好需要排序的位数。将所有需要排序的数的每一位分割，根据各位将待排序的数字进行排列，之后根据百位… 时间复杂度:O(kn)

概述 选泡插, 快归堆希桶计基, n方n老(log)n一三, 对n加kn乘k, 不稳稳稳不稳稳, 不稳不稳稳稳稳。 排序算法 平均时间复杂度 最好情况 最坏情况 空间复杂度 排序方式 稳定性 冒泡排序(BubbleSort) O(n 2 ) O(n) O(n 2 ) O(1) In-place 稳定 选择排序(SelectSort) O(n 2 ) O(n 2 ) O(n 2 ) O(1) In-place 不稳 插入排序(InsertSort) O(n 2 ) O(n) O(n 2 ) O(1) In-place 稳定 希尔排序(ShellSort) O(n 1.3 ) O(n) O(n log 2 n) O(1) In-place 不稳 归并排序(MergeSort) O(n log n) O(n log n) O(n log n) O(n) Out-place 稳定 快速排序(QuickSort) O(n log n) O(n log n) O(n 2 ) O(log n) In-place 不稳 堆排序(HeapSort) O(n log n) O(n log n) O(n log n) O(1) In-place 不稳 计数排序(CountSort) O(n + k) O(n + k) O(n + k) O(k) Out-place 稳定 桶排序(BucketSort)

一、算法思想 　　1、轴点的概念 　　 轴点：左侧的元素均不大于轴点，右侧的元素，均不小于轴点。 　 2、其实这样来说，这个序列已经有了一定的有序性，现在我们已经将整个的数据分为了三个部分： 　　左侧无序部分 + 轴点 +右侧无序部分 　　那么我们接下来要做的，就是将这个过程迭代下去，不断的将无序部分拆分为两个无序部分，直至最后全部有序。 　　这样就会有两个问题： 　　（1）、如何选取一个轴点（有可能我们自己设定的轴点并不存在，所以最好是从数据中选取一个轴点） 　　（2）、如何将这个轴点移动到这样的一个位置：即左侧的数据都比这个轴点小，右侧的数据大于等于这个轴点 二、算法过程 　　算法的具体过程如下： 　　 　　在数据的最开始：灰色部分代表我们将要排序的数据，它的最低位的秩（也就是数组数据的位置）用lo来表示，右侧最高位用hi来表示。 　　 1、随后我们去除左侧的第一个位置的数据当做轴点（也就是 lo位置），可以看到左侧位置是一个虚线框，也就是表示这个位置可以看做是空的。 　　2、我们设立一个哨兵，从最右侧到最左侧一次的遍历每一个位置，如果发现数据比轴点大，那么就接着移动（也就是数据原本就在右侧，所以不用进行操作） 　　如果发现了比轴点小的数据，就移动到左侧那个空节点的位置，这个时候右侧那个数据位置就变成了空。 　　3、随后左侧的哨兵从最左侧到最右侧依次遍历，如果数据都是比轴点小的

文件源于 : https://www.cnblogs.com/Jason-Xiang/p/8567751.html 排序算法 平均时间复杂度 冒泡排序 O(n2) 选择排序 O(n2) 插入排序 O(n2) 希尔排序 O(n1.5) 快速排序 O(N*logN) 归并排序 O(N*logN) 堆排序 O(N*logN) 基数排序 O(d(n+r)) 一. 冒泡排序(BubbleSort) 基本思想： 两个数比较大小，较大的数下沉，较小的数冒起来。 过程： 比较相邻的两个数据，如果第二个数小，就交换位置。 从后向前两两比较，一直到比较最前两个数据。最终最小数被交换到起始的位置，这样第一个最小数的位置就排好了。 继续重复上述过程，依次将第2.3...n-1个最小数排好位置。 平均时间复杂度： O(n2) java代码实现： public static void BubbleSort(int [] arr){ int temp;//临时变量 for(int i=0; i<arr.length-1; i++){ //表示趟数，一共arr.length-1次。 for(int j=arr.length-1; j>i; j--){ if(arr[j] < arr[j-1]){ temp = arr[j]; arr[j] = arr[j-1]; arr[j-1] = temp; } } } }

计数排序 一、什么是计数排序 　　当我们排序的时候，是对于一定范围的字符进行排序的。 　　比如如果是a-z26个字母排序，这个时候可能出现的字母总数一共是26个，依次遍历字母出现的顺序，然后按照字母顺序以及出现的次数重新排列就可以了。 　　如果是数字排序，也是这样，找到出现的数字的范围，然后对于范围以内的进行遍历，确定不同的数字出现的次数，然后按照次数一次排序。 二、例子 　　例子一 　　有这样的字母: abdefde 　　当我们遍历的时候得到如下的表格 字母 a b c d e f 遍历之后得到每个字母出现的次数 1 1 0 2 2 1 　　随后按照每个字母的顺序，出现几次就排几个，排序之后出现的结果如图所示： 秩 0 1 2 3 4 5 6 字母 a b d d e e f 　　例子二 　　有这样的一组数字：　 　　 　当我们遍历之后得到该范围内每个数字的出现次数： 数字 7, 8 9 10 11 出现次数 1 2 1 0 1 　　当我们按照每个数字出现的次数由大到小排序之后： 秩 0 1 2 3 4 数字 7 8 8 9 11 三、算法实现 　　对于数字排序的过程加以说明： 　　上面的数字中，我们找到数字的最大值与最小值，这样获得了排序的元素范围以及大小 　　我们可以看到： int max=11, min=7 ; View Code 　　随后我们设置一个大小为 size=