本文主要是在准备秋招找工作时刷左神的算法课所记录的笔记，为方便自己查找而整理在博客中。因目前表达能力有限，本文主要参考 https://github.com/JourWon/sort-algorithm
的内容，代码部分是按照左神视频所讲内容编写。

0、排序算法说明

0.1 排序的定义

对一序列对象根据某个关键字进行排序。

0.2 术语说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度： 一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。

0.3 算法总结

图片名词解释：
n: 数据规模
k: “桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

0.4 算法分类

0.5 比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。 在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logn次，所以时间复杂度平均O(nlogn)。 比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。 非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。 非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

1、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

1.2 动图演示

1.3 代码实现

冒泡排序需要两个嵌套的循环. 其中, 外层循环移动游标; 内层循环遍历游标及之后(或之前)的元素, 通过两两交换的方式, 每次只确保该内循环结束位置排序正确, 然后内层循环周期结束, 交由外层循环往后(或前)移动游标, 随即开始下一轮内层循环, 以此类推, 直至循环结束.

public static void bobbleSort(int[] arr){if(arr==null || arr.length<2){return;}// 外层循环控制比较轮数ifor(int i=arr.length-1;i>0;i--){// 内层循环控制每一轮比较次数，每进行一轮排序都会找出一个较大值for(int j=0;j<i;j++){if(arr[j]>arr[j+1]){swap(arr,j,j+1);}}}}public static void swap(int[] arr,int x,int y){int temp=arr[x];arr[x]=arr[y];arr[y]=temp;}

1.4 算法分析

最佳情况： T ( n ) = O ( n ) T(n) = O(n) T(n)=O(n) 最差情况: T ( n ) = O ( n 2 ) T(n) = O(n^2) T(n)=O(n2) 平均情况： T ( n ) = O ( n 2 ) T(n) = O(n^2) T(n)=O(n2)

2、选择排序

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

• 初始状态：无序区为R[1…n]，有序区为空；
• 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
• n-1趟结束，数组有序化了。

2.2 动图演示

2.3 代码实现

public static void selectionSort(int[] arr){if(arr==null || arr.length<2)return;for(int i=0;i<arr.length-1;i++){// 保存最小数的索引int minIndex=i;for(int j=i+1;j<arr.length;j++){minIndex=arr[j]<arr[minIndex]?j:minIndex;}swap(arr,minIndex,i);}}public static void swap(int[] arr,int x,int y){int temp=arr[x];arr[x]=arr[y];arr[y]=temp;}

2.4算法分析

最佳情况： T ( n ) = O ( n 2 ) T(n) = O(n^2) T(n)=O(n2) 最差情况： T ( n ) = O ( n 2 ) T(n) = O(n^2) T(n)=O(n2) 平均情况： T ( n ) = O ( n 2 ) T(n) = O(n^2) T(n)=O(n2)

选择排序的简单和直观名副其实，这也造就了它”出了名的慢性子”，无论是哪种情况，哪怕原数组已排序完成，它也将花费将近 n 2 2 \frac{n^2}{2} 2n2​次遍历来确认一遍。即便是这样，它的排序结果也还是不稳定的。 唯一值得高兴的是，它并不耗费额外的内存空间。

3、插入排序

插入排序的设计初衷是往有序的数组中快速插入一个新的元素。它的算法思想是：把要排序的数组分为了两个部分, 一部分是数组的全部元素(除去待插入的元素), 另一部分是待插入的元素; 先将第一部分排序完成, 然后再插入这个元素. 其中第一部分的排序也是通过再次拆分为两部分来进行的.

插入排序由于操作不尽相同, 可分为 直接插入排序 , 折半插入排序(又称二分插入排序), 链表插入排序 , 希尔排序 。这里介绍的是直接插入排序。直接插入排序的基本思想是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

3.2 动图演示

3.3 代码实现

public static void insertionSort(int[] arr){if(arr==null || arr.length<2)return;for(int i=1;i<arr.length;i++){for(int j=i-1;j>=0;j--){if(arr[j]>arr[j+1]){swap(arr,j,j+1);}}}}public static void swap(int[] arr,int x,int y){int temp=arr[x];arr[x]=arr[y];arr[y]=temp;}

3.4 算法分析

• 最好情况下，排序前对象已经按照要求的有序。比较次数(KCN)： n − 1 n−1 n−1；移动次数(RMN)为0。则对应的时间复杂度为 O ( n ) O(n) O(n)。
• 最坏情况下，排序前对象为要求的顺序的反序。第i趟时第i个对象必须与前面i个对象都做排序码比较，并且每做1次比较就要做1次数据移动（从上面给出的代码中看出）。比较次数(KCN)： ∑ i = 1 n − 1 i = n ( n − 1 ) 2 ≈ n 2 2 \sum_{i=1}^{n-1} i=\frac{n(n-1)}{2}\approx\frac{n^2}{2} ∑i=1n−1​i=2n(n−1)​≈2n2​; 移动次数(RMN)为： ∑ i = 1 n − 1 i = n ( n − 1 ) 2 ≈ n 2 2 \sum_{i=1}^{n-1} i=\frac{n(n-1)}{2}\approx\frac{n^2}{2} ∑i=1n−1​i=2n(n−1)​≈2n2​。则对应的时间复杂度为 O ( n 2 ) O(n2) O(n2)。
• 如果排序记录是随机的，那么根据概率相同的原则，在平均情况下的排序码比较次数和对象移动次数约为 n 2 2 \frac{n^2}{2} 2n2​，因此，直接插入排序的平均时间复杂度为 O ( n 2 ) O(n2) O(n2)。

4、归并排序

归并排序是建立在归并操作上的一种有效的排序算法，1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

4.1 算法描述

归并排序可通过两种方式实现：

• 自上而下的递归
• 自下而上的迭代

递归法（假设序列共有n个元素）：

• 将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
• 将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
• 重复步骤②，直到所有元素排序完毕。

迭代法

• 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
• 设定两个指针，最初位置分别为两个已经排序序列的起始位置
• 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
• 重复步骤③直到某一指针到达序列尾
• 将另一序列剩下的所有元素直接复制到合并序列尾

4.2 动图演示

这里的是递归法的动图演示

4.3 代码实现

归并排序其实要做两件事：

• 分解：将序列每次折半拆分
• 合并：将划分后的序列段两两排序合并

因此，归并排序实际上就是两个操作，拆分+合并

如何合并？
arr[L…mid]为第一段，L[mid+1…R]为第二段，并且两端已经有序，现在我们要将两端合成达到L[L…R]并且也有序。

首先依次从第一段与第二段中取出元素比较，将较小的元素赋值给help[]
重复执行上一步，当某一段赋值结束，则将另一段剩下的元素赋值给help[]
此时将help[]中的元素复制给arr[]，则得到的arr[L…R]有序

如何分解？
在这里，我们采用递归的方法，首先将待排序列分成A,B两组；然后重复对A、B序列分组；直到分组后组内只有一个元素，此时我们认为组内所有元素有序，则分组结束。

public static void mergeSort(int[] arr){if(arr==null || arr.length<2)return;sortProcess(arr,0,arr.length-1);
}
//先左边的排好序，再右边的排好序，然后合并使整体有序
public static void sortProcess(int[] arr,int L,int R){if(L == R)return;int mid= L+((R-L)>>1); //L和R的中点位置(L+R)/2sortProcess(arr,L,mid);sortProcess(arr,mid+1,R);merge(arr,L,mid,R);
}
//合并排好序的左右两部分
public static void merge(int[] arr,int L,int mid,int R){int[] help=new int[R-L+1];int i=0;int p1=L;int p2=mid+1;while (p1<=mid && p2<=R){help[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];}while (p1<=mid){help[i++]=arr[p1++];}while (p2<=R){help[i++]=arr[p2++];}for(i=0;i<help.length;i++){arr[L+i]=help[i];}
}

4.4 算法分析

最佳情况： T ( n ) = O ( n ) T(n) = O(n) T(n)=O(n) 最差情况： T ( n ) = O ( n l o g n ) T(n) = O(nlogn) T(n)=O(nlogn) 平均情况： T ( n ) = O ( n l o g n ) T(n) = O(nlogn) T(n)=O(nlogn)

从效率上看，归并排序可算是排序算法中的”佼佼者”. 假设数组长度为n，那么拆分数组共需 l o g n logn logn, 又每步都是一个普通的合并子数组的过程，时间复杂度为 O ( n ) O(n) O(n)， 故其综合时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn)。另一方面， 归并排序多次递归过程中拆分的子数组需要保存在内存空间， 其空间复杂度为 O ( n ) O(n) O(n)。

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

5、快速排序

快速排序（Quicksort）是对冒泡排序的一种改进，借用了分治的思想，由C. A. R. Hoare在1962年提出。
快速排序的基本思想：挖坑填数+分治法。
首先选一个轴值(pivot，也有叫基准的)，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

5.1 算法描述

快速排序使用分治策略来把一个序列（list）分为两个子序列（sub-lists）。步骤为：

• 从数列中挑出一个元素，称为”基准”（pivot）。
• 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
• 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

5.2 动图演示

5.3 代码实现

代码实现的是使用荷兰国旗问题改进的随机快速排序

public static void quickSort(int[] arr){if(arr==null || arr.length<2)return;quickSort(arr,0,arr.length-1);
}public static void quickSort(int[] arr,int l,int r){if(l<r){swap(arr,l+(int)(Math.random()*(r-l+1)),r);//随机快排int[] p=partition(arr,l,r);//使用荷兰国旗问题的方法改进，一次可以确定多个相同的数quickSort(arr,l,p[0]-1);quickSort(arr,p[1]+1,r);}
}public static int[] partition(int[] arr,int l,int r){int less=l-1;int more=r;while (l<more){if(arr[l]<arr[r]){swap(arr,++less,l++);}else if(arr[l]>arr[r]){swap(arr,--more,l);}elsel++;}swap(arr,more,r);return new int[]{less+1,more}; // =num 的左右边界
}public static void swap(int[] arr,int i,int j){int temp=arr[i];arr[i]=arr[j];arr[j]=temp;
}

5.4 算法分析

最佳情况： T ( n ) = O ( n log ⁡ 2 n ) T(n) = O(n\log_2n) T(n)=O(nlog2​n) 最差情况： T ( n ) = O ( n 2 ) T(n) = O(n^2) T(n)=O(n2) 平均情况： T ( n ) = O ( n log ⁡ 2 n ) T(n) = O(n\log_2n) T(n)=O(nlog2​n)　
快速排序是通常被认为在同数量级 O ( n log ⁡ 2 n ) O(n\log_2n) O(nlog2​n)的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。或随机选择一个待排数组中的数做为基准。快速排序是一个不稳定的排序方法。

快速排序排序效率非常高。虽然它运行最糟糕时将达到 O ( n ² ) O(n²) O(n²)的时间复杂度, 但通常平均来看, 它的时间复杂为 O ( n log ⁡ 2 n ) O(n\log_2n) O(nlog2​n), 比同样为 O ( n log ⁡ 2 n ) O(n\log_2n) O(nlog2​n)时间复杂度的归并排序还要快. 快速排序似乎更偏爱乱序的数列, 越是乱序的数列, 它相比其他排序而言, 相对效率更高.

使用荷兰国旗问题改进的快速排序算法的额外空间复杂度为 O ( log ⁡ 2 n ) O(\log_2n) O(log2​n)
经典的快速排序算法的额外空间复杂度为 O ( 1 ) O(1) O(1)

Tips: 同选择排序相似, 快速排序每次交换的元素都有可能不是相邻的, 因此它有可能打破原来值为相同的元素之间的顺序. 因此, 快速排序并不稳定.

6、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

6.1 算法描述

• 将初始待排序关键字序列 ( R 1 , R 2 … . R n ) (R_1,R_2….R_n) (R1​,R2​….Rn​)构建成大顶堆，此堆为初始的无序区；
• 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区 ( R 1 , R 2 , … … R n − 1 ) (R_1,R_2,……R_{n-1}) (R1​,R2​,……Rn−1​)和新的有序区 ( R n ) (R_n) (Rn​),且满足R[1,2…n-1]<=R[n]；
• 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区 ( R 1 , R 2 , … … R n − 1 ) (R_1,R_2,……R_{n-1}) (R1​,R2​,……Rn−1​)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区 ( R 1 , R 2 , … … R n − 2 ) (R_1,R_2,……R_{n-2}) (R1​,R2​,……Rn−2​)和新的有序区 ( R n − 1 , R n ) (R_{n-1},R_n) (Rn−1​,Rn​)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

6.2 动图演示

6.3 代码实现

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆函数，二是反复调用建堆函数以选择出剩余未排元素中最大的数来实现排序的函数。

总结起来就是定义了以下几种操作：

最大堆调整（heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
创建最大堆（heapInsert）：将堆所有数据重新排序
堆排序（heapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算
对于堆节点的访问：

父节点i的左子节点在位置：(2i+1);
父节点i的右子节点在位置：(2i+2);
子节点i的父节点在位置：floor((i-1)/2);

public static void heapSort(int[] arr){if(arr==null || arr.length<2)return;//创建一个大根堆for(int i=0;i<arr.length;i++){heapInsert(arr,i);}//大根堆的第一个数和最后一个数交换int size=arr.length;swap(arr,0,--size); //交换之后大根堆对应的数组长度减一//调整交换后的数组(交换后的数组大小减一，此时排好一个数)while (size>0){heapify(arr,0,size);swap(arr,0,--size);}
}//插入一个数，使当前数组为一个大根堆
public static void heapInsert(int[] arr,int index){while (arr[index]>arr[(index-1)/2]){//插入的数大于他的父节点，一直向上调整直到父节点大于indexswap(arr,index,(index-1)/2);index=(index-1)/2;}
}//当大根堆中有一个数变小时，调整大根堆
public static void heapify(int[] arr,int index,int size){int left=2*index+1;//左孩子while (left<size){int largest; //记录左右孩子和index中较大的数的下标if(left+1<size && arr[left+1]>arr[left]){ //右孩子存在且右孩子大于左孩子,较大的数的下标为右孩子的下标largest=left+1;}else  //否则，较大的数的下标为左孩子的下标largest=left;largest = arr[largest] > arr[index] ? largest : index; //比较孩子节点中较大的值是否比当前值大，记录较大的值if (largest == index) { //如果当前值就是当前值和左右孩子节点的值中最大的，则不再需要调整break;}swap(arr, largest, index); //否则当前值和左右孩子中较大的交换index = largest;//继续上面的过程left = index * 2 + 1;}
}

6.4 算法分析

①. 建立堆的过程, 从length/2 一直处理到0, 时间复杂度为 O ( n ) O(n) O(n);
②. 调整堆的过程是沿着堆的父子节点进行调整, 执行次数为堆的深度, 时间复杂度为 O ( l o g 2 n ) O(log_2n) O(log2​n);
③. 堆排序的过程由n次第②步完成, 时间复杂度为 O ( n l o g 2 n ) O(nlog_2n) O(nlog2​n).
最佳情况： T ( n ) = O ( n l o g 2 n ) T(n) = O(nlog_2n) T(n)=O(nlog2​n) 最差情况： T ( n ) = O ( n l o g 2 n ) T(n) = O(nlog_2n) T(n)=O(nlog2​n) 平均情况： T ( n ) = O ( n l o g 2 n ) T(n) = O(nlog_2n) T(n)=O(nlog2​n)
Tips: 由于堆排序中初始化堆的过程比较次数较多, 因此它不太适用于小序列. 同时由于多次任意下标相互交换位置, 相同元素之间原本相对的顺序被破坏了, 因此, 它是不稳定的排序.

7、计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

7.1 算法描述

• 找出待排序的数组中最大和最小的元素；
• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

7.2 动图演示

7.3 代码实现

7.4 算法分析

8、桶排序

8.1 算法描述

8.2 动图演示

8.3 代码实现

8.4 算法分析

9、基数排序

9.1 算法描述

9.2 动图演示

9.3 代码实现

9.4 算法分析

10、工程中的综合排序算法

工程中的综合排序算法使用多种算法。
数组长度很长时，首先判断是否是基础类型：

• 基础类型：快速排序。基础类型值一样的都一样，因此不需要稳定性
• 自定义类型：归并排序

数组长度很短时（小于60），直接用插入排序，因为插入排序常数项很低，在小样本情况下n平方的劣势显示不出来。
在递归的情况下，当子问题规模小于一定值（例如60）时开始使用插入排序。

11、有关排序问题的补充:

1.归并排序的额外空间复杂度可以变成O(1)，但是非常难，不需要掌握，可以搜“归并排序 内部缓存法”
2.快速排序可以做到稳定性问题，但是非常难，不需要掌握，可以搜“01 stable sort”
(荷兰国旗问题不能实现稳定性)
3.有一道题目，是奇数放在数组左边，偶数放在数组右边，还要求原始的相对次序不变，额外空间复杂度O(1),时间复杂度O(n)。碰到这个问题，可以怼面试官，面试官非良人。就是01 stable sort问题，很难。快速排序做不到稳定性。

排序算法总结和java实现相关推荐

1. 选择排序算法（基于Java实现）

   title: 选择排序算法(基于Java实现) tags: 选择算法 选择排序算法原理及代码实现: 一.选择排序算法的原理 选择排序算法的实现思路有点类似插入排序,也分已排序区间和未排序区间.但是选择 ...

2. 桶排序算法（基于Java实现）

   title: 桶排序算法(基于Java实现) tags: 桶排序算法 桶排序算法的原理和代码实现 一.桶排序算法的原理 桶排序,顾名思义,会用到"桶",核心思想是将要排序的数据分到 ...

3. 插入排序算法 java_排序算法实现-插入排序(Java版本）

   原标题:排序算法实现-插入排序(Java版本) 插入排序(英语:Insertion Sort)是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到 ...

4. java 奇偶数据排序算法,简单讲解奇偶排序算法及在Java数组中的实现

   简单讲解奇偶排序算法及在Java数组中的实现 奇偶排序是一个比较有个性的排序,基本思路是奇数列排一趟序,偶数列排一趟序,再奇数排,再偶数排,直到全部有序 举例吧, 待排数组 [6 2 4 1 5 9] ...

5. java排序算法总结_排序算法总结及Java实现

   1. 整体介绍 分类 排序大的分类可以分为两种,内排序和外排序.在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序.主要需要理解的都是内排序算法: 内排序可以分为 ...

6. 买什么数据结构与算法，这里有：动态图解十大经典排序算法（含JAVA代码实现）

   上篇的动图数据结构反响不错,这次来个动图排序算法大全.数据结构与算法,齐了. 几张动态图捋清Java常用数据结构及其设计原理 本文将采取动态图+文字描述+正确的java代码实现来讲解以下十大排序算法: ...

7. java array 元素的位置_数据结构与算法：动态图解十大经典排序算法（含JAVA代码实现）...

   点击上方"JAVA",星标公众号 重磅干货,第一时间送达 本文将采取动态图+文字描述+正确的java代码实现来讲解以下十大排序算法: 冒泡排序 选择排序 插入排序 希尔排序 归并排 ...

8. 【转】排序算法复习（Java实现） （二）： 归并排序，堆排序，桶式排序，基数排序...

   http://www.blogjava.net/javacap/archive/2007/12/14/167618.html 六 归并排序 算法思想是每次把待排序列分成两部分,分别对这两部分递归地用归 ...

9. 排序算法的总结——Java实现

   前言 简单归纳一下最近学习的排序算法,如果有什么错误的地方还请大家指教. 本文介绍了七种经典排序算法,包括冒泡排序,选择排序,插入排序,希尔排序,归并排序,快速排序以及堆排序,并且讨论了各种算法的进一 ...

最新文章

1. hibernate c3p0 mysql_hibernate-使用c3p0数据库连接池，以及其它配置
2. sosdp 二进制子集的贡献
3. Python 判断一个数是不是质数
4. 直播预告丨爆款独立站如何利用数据提升经营效率？
5. linux内存free低,Linux上的内存使用情况与`free`不匹配
6. Unity——Shader
7. flutter 真机无法调试 sdk报错_老许，你要转Flutter不要？只要你开金口，面试题现在就给你送来...
8. svn的使用总结（待补充）
9. 03-03 java 顺序语句结构，选择结构if语句
10. python学习笔记之其它
11. mysql同步三张表如何用事务_MySql-第三部分(外键, 多表连接, 事务,视图 )
12. distpicker实现省市级联动
13. 有什么软件可以测试U盘性能,最新版本：U盘性能检查测试软件简介
14. 【信息系统项目管理师】第十三章 项目合同管理思维导图
15. 3D 专业词汇 （转）
16. python小乌龟绘制迷宫_用turtle不断的画回字迷宫
17. 【转载】Excel操作 Microsoft.Office.Interop.Excel.dll的使用
18. const、*、的大乱斗
19. 全栈开发和web开发_全栈开发人员：这是什么，以及如何成为一个完整的开发人员...
20. SIR SIRE 传染病预测模型与代码应用之概念篇

热门文章

1. css的内联是什么,css中什么是内联元素
2. Python数据分析及可视化（Matplotlib， Plotly，random）实例：双色球根据往期数据产生随机号码
3. 唱情歌 设计日记（一）：电脑，手机，电视机，和家
4. PsPing 使用手冊及範例
5. Fastdfs集群搭建
6. kubernetes容器云平台入门之基础理论
7. GCC版本升级到指定版本
8. 最详细的国内各银行收费情况一览
9. Postman Chrome插件
10. 【tensorflow】随机数生成