几种常见的排序算法
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
排序算法可以分为内部排序和外部排序：
内部排序是数据记录在内存中进行排序。
外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序等。
1、冒泡排序
冒泡排序通过重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，直到没有再需要交换的元素为止（对n个项目需要O(n^2)的比较次数）。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
实现步骤
- 比较相邻的元素，如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
图解
Java代码实现
// 冒泡排序
public void BubbleSort ( int[] arr){
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr, j + 1, j);
}
}
}
}
// 交换
public static int[] swap ( int[] arr, int x, int y){
if (x >= arr.length && x < 0 && y >= arr.length && y < 0) {
System.out.println("参数不合法");
return null;
}
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
return arr;
}
性能分析
最差时间复杂度：O(n^2)
最优时间复杂度：O(n)
平均时间复杂度：O(n^2)
最差空间复杂度：O(n)，需要辅助空间：O(1)
2、选择排序
选择排序方法有简单选择排序和堆排序，这里说的是简单选择排序
设所排序序列的记录个数为n，i取1，2，…，n-1 。
从所有n-i+1个记录（Ri，Ri+1，…，Rn）中找出排序码最小（或最大）的记录，与第i个记录交换，执行n-1趟后就完成了记录序列的排序。
实现步骤
-
将第一个值看成最小值
-
然后和后续的比较找出最小值和下标
-
交换本次遍历的起始值和最小值
说明：每次遍历的时候，将前面找出的最小值，看成一个有序的列表，后面的看成无序的列表，然后每次遍历无序列表找出最小值。
图解
示例
以排序数组｛3，2，1，4，6，5｝为例：
性能分析
- 在简单选择排序过程中，所需移动记录的次数比较少。在最好的情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。
- 最坏情况下，即待排序记录初始状态是按第一条记录最大，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-1）。
- 简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况无关。
当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较操作的时间复杂度为O(n^2)，进行移动操作的时间复杂度为O(n)。
简单选择排序是不稳定排序。
Java代码实现
public void selectSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
// 默认第一个值为最小值
int min = arr[i];
// 记录最小值，下角标
int index = i;
for (int j = i+1; j < arr.length; j++) {
if (arr[j] < min) {
index = j;
min = arr[j];
}
}
// 将最小值与本次循环的开始值交换
//说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找无序的最小值，做替换
int temp = arr[i];
arr[i] = min;
arr[index] = temp;
}
}
public void selectSort1(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int index = i; // 最小值的下角标
for (int j = i + 1; j < arr.length; j++) {
// 查找最小值索引
if (arr[j] < arr[index]) index = j;
}
if (index != i) { // 如果最小值的索引不是i,则交换位置
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
}
3、插入排序
-
将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，是稳定的排序方法。
-
插入排序又分为：直接插入排序和折半插入排序。
实现步骤
- 默认从第二个数据开始比较。
- 如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入（狡猾）。否则，退出循环
说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入（交换）。否则退出。
图解
Java 代码实现
public void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
// 内存循环，与前面排好序的数据比较，如果后面的数据小于前面的则交换
if (arr[j] < arr[j-1]) {
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
} else {
// 如果不小于，说明插入完毕，退出内层循环
break;
}
}
}
}
性能分析
空间复杂度：O(1)
平均时间复杂度：O(n^2)
最差情况：反序，需要移动n*(n-1)/2个元素 ，运行时间为O(n^2)。
最好情况：正序，不需要移动元素，运行时间为O(n)．
4、希尔排序
希尔排序法(缩小增量法)属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。
把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个数组恰被分成一组，算法便终止。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
-
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
-
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
实现过程
- 基本上和插入排序一样的道理
- 不一样的地方在于，每次循环的步长，通过减半的方式来实现
说明：基本原理和插入排序类似，不一样的地方在于。通过间隔多个数据来进行插入排序。
图解
示例
先取一个正整数d1小于n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2小于d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止。
例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
然后我们对每列进行排序：
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. 这时10已经移至正确位置了，然后再以3为步长进行排序：
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后变为：
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
最后以1步长进行排序（此时就是简单的插入排序了）。
Java 代码实现
public static void shellSort(int[] arr){
//gap表示数组分组的步长，temp缓存插入排序时那列需要插入排序的最后一个数字的值
int length = arr.length， gap = 1， temp， i， j;
//计算初始步长
while(gap < length/3) gap = gap*3+1;
//循环所有的步长，最后步长必为1
for(; gap > 0; gap /= 3){
//每一列依次向前做插入排序，i为该列需要做插入排序的最下面的那个位置。
//在该行中依次向后挪动，该行结束之后再从下一行依次向后挪动
for(i=gap; i<length; i++){
//记录本次插入排序列最下面位置的值
temp = arr[i];
for(j=i-gap; j>=0&&arr[j]>temp; j-=gap){
arr[j+gap] = arr[j];
}
//使用arr[i]的原始值来填补空缺，完成该列中本次上面数字的插入排序。
//由于for循环最后一次j的值自减gap，因此j+gap才是正确的位置
arr[j+gap] = temp;
}
}
}
性能分析
希尔排序是一个不稳定的排序，其时间复杂度受步长（增量）的影响。
空间复杂度：Ｏ(1)
时间复杂度：平均 ：O(n^1.3)
最好：O(n)
最坏：O(n^2)
5、快速排序
快速排序是对冒泡排序的一种改进，又称划分交换排序。
基本思想
快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列：
3 1 2 5 4 6 9 7 10 8
在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位置是k。现在就需要寻找这个k，并且以第k位为分界点，左边的数都小于等于6，右边的数都大于等于6。想一想，你有办法可以做到这点吗？
方法其实很简单：分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换他们。这里可以用两个变量i和j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。刚开始的时候让哨兵i指向序列的最左边（即i=1），指向数字6。让哨兵j指向序列的最右边（即=10），指向数字8。
首先哨兵j开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵j先出动，这一点非常重要（请自己想一想为什么）。哨兵j一步一步地向左挪动（即j–），直到找到一个小于6的数停下来。接下来哨兵i再一步一步向右挪动（即i++），直到找到一个数大于6的数停下来。最后哨兵j停在了数字5面前，哨兵i停在了数字7面前。
现在交换哨兵i和哨兵j所指向的元素的值。交换之后的序列如下：
6 1 2 5 9 3 4 7 10 8
到此，第一次交换结束。接下来开始哨兵j继续向左挪动（再友情提醒，每次必须是哨兵j先出发）。他发现了4（比基准数6要小，满足要求）之后停了下来。哨兵i也继续向右挪动的，他发现了9（比基准数6要大，满足要求）之后停了下来。此时再次进行交换，交换之后的序列如下：
6 1 2 5 4 3 9 7 10 8
第二次交换结束，“探测”继续。哨兵j继续向左挪动，他发现了3（比基准数6要小，满足要求）之后又停了下来。哨兵i继续向右移动，糟啦！此时哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。说明此时“探测”结束。我们将基准数6和3进行交换。交换之后的序列如下：
3 1 2 5 4 6 9 7 10 8
到此第一轮“探测”真正结束。此时以基准数6为分界点，6左边的数都小于等于6，6右边的数都大于等于6。回顾一下刚才的过程，其实哨兵j的使命就是要找小于基准数的数，而哨兵i的使命就是要找大于基准数的数，直到i和j碰头为止。
OK，解释完毕。现在基准数6已经归位，它正好处在序列的第6位。此时我们已经将原来的序列，以6为分界点拆分成了两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“9 7 10 8”。接下来还需要分别处理这两个序列。因为6左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理6左边和右边的序列即可。现在先来处理6左边的序列现吧。
左边的序列是“3 1 2 5 4”。请将这个序列以3为基准数进行调整，使得3左边的数都小于等于3，3右边的数都大于等于3。好了开始动笔吧
如果你模拟的没有错，调整完毕之后的序列的顺序应该是：
2 1 3 5 4
OK，现在3已经归位。接下来需要处理3左边的序列“2 1”和右边的序列“5 4”。对序列“2 1”以2为基准数进行调整，处理完毕之后的序列为“1 2”，到此2已经归位。序列“1”只有一个数，也不需要进行任何处理。至此我们对序列“2 1”已全部处理完毕，得到序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下：
1 2 3 4 5 6 9 7 10 8
对于序列“9 7 10 8”也模拟刚才的过程，直到不可拆分出新的子序列为止。最终将会得到这样的序列，如下
1 2 3 4 5 6 7 8 9 10
到此，排序完全结束。细心的同学可能已经发现，快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了。下面上个霸气的图来描述下整个算法的处理过程。
实现步骤
- 确认列表第一个数据为中间值，第一个值看成空缺（低指针空缺）。
- 然后在剩下的队列中，看成有左右两个指针（高低）。
- 开始高指针向左移动，如果遇到小于中间值的数据，则将这个数据赋值到低指针空缺，并且将高指针的数据看成空缺值（高指针空缺）。然后先向右移动一下低指针，并且切换低指针移动。
- 当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作。
- 直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。
- 然后将中间值的左右两边看成行的列表，进行快速排序操作
图解
Java 代码实现
public static void quickSort(int[] arr, int low, int high) {
//如果指针在同一位置(只有一个数据时)，退出
if (high - low < 1) {
return;
}
//标记，从高指针开始，还是低指针（默认高指针）
boolean flag = true;
//记录指针的其实位置
int start = low;
int end = high;
//默认中间值为低指针的第一个值
int midValue = arr[low];
while (true) {
//高指针移动
if (flag) {
//如果列表右方的数据大于中间值，则向左移动
if (arr[high] > midValue) {
high--;
} else if (arr[high] < midValue) {
//如果小于，则覆盖最开始的低指针值，并且移动低指针，标志位改成从低指针开始移动
arr[low] = arr[high];
low++;
flag = false;
}
} else {
//如果低指针数据小于中间值，则低指针向右移动
if (arr[low] < midValue) {
low++;
} else if (arr[low] > midValue) {
//如果低指针的值大于中间值，则覆盖高指针停留时的数据，并向左移动高指针。切换为高指针移动
arr[high] = arr[low];
high--;
flag = true;
}
}
//当两个指针的位置相同时，则找到了中间值的位置，并退出循环
if (low == high) {
arr[low] = midValue;
break;
}
}
//然后出现有，中间值左边的小于中间值。右边的大于中间值。
//然后在对左右两边的列表在进行快速排序
quickSort(arr, start, low -1);
quickSort(arr, low + 1, end);
}
性能分析
时间复杂度：最差：O(N^2) 同冒泡一样
平均：O(NlogN)
6、归并排序
归并排序，是创建在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。
即先使每个子序列有序，再将两个已经排序的序列合并成一个序列的操作。若将两个有序表合并成一个有序表，称为二路归并。
示例
设有数列{6，202，100，301，38，8，1}
初始状态：6，202，100，301，38，8，1
第一次归并后：{6，202}，{100，301}，{8，38}，{1}，比较次数：3；
第二次归并后：{6，100，202，301}，{1，8，38}，比较次数：4；
第三次归并后：{1，6，8，38，100，202，301}，比较次数：4；
总的比较次数为：3+4+4=11，；
逆序数为14；
实现步骤
- 将列表按照对等的方式进行拆分
- 拆分小最小快的时候，在将最小块按照原来的拆分，进行合并
- 合并的时候，通过左右两块的左边开始比较大小。小的数据放入新的块中
说明：简单一点就是先对半拆成最小单位，然后将两半数据合并成一个有序的列表
图解
Java 代码实现
public static void mergeSort(int[] arr, int start, int end) {
//判断拆分的不为最小单位
if (end - start > 0) {
//再一次拆分，知道拆成一个一个的数据
mergeSort(arr, start, (start + end) / 2);
mergeSort(arr, (start + end) / 2 + 1, end);
//记录开始/结束位置
int left = start;
int right = (start + end) / 2 + 1;
//记录每个小单位的排序结果
int index = 0;
int[] result = new int[end - start + 1];
//如果查分后的两块数据，都还存在
while (left <= (start + end) / 2 && right <= end) {
//比较两块数据的大小，然后赋值，并且移动下标
if (arr[left] <= arr[right]) {
result[index] = arr[left];
left++;
} else {
result[index] = arr[right];
right++;
}
//移动单位记录的下标
index++;
}
//当某一块数据不存在了时
while (left <= (start + end) / 2 || right <= end) {
//直接赋值到记录下标
if (left <= (start + end) / 2) {
result[index] = arr[left];
left++;
} else {
result[index] = arr[right];
right++;
}
index++;
}
//最后将新的数据赋值给原来的列表，并且是对应分块后的下标。
for (int i = start; i <= end; i++) {
arr[i] = result[i - start];
}
}
}
排序过程
性能分析
归并排序速度仅次于快速排序，为稳定排序算法。（即相等的元素的顺序不会改变），一般用于对总体无序，但是各子项相对有序的数列。
时间复杂度为：O(nlogn)
空间复杂度为：O(n)
归并排序比较占用内存，但却是一种效率高且稳定的算法。
452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
