七大排序基本实现——Java
Posted 王嘻嘻-
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了七大排序基本实现——Java相关的知识，希望对你有一定的参考价值。
目录
0、附录
1、冒泡排序（Bubble Sort）
1.1 概念简述
冒泡排序是一种简单的排序算法。它重复地便利要排序的数列，一次比较相邻的两个元素，如果不符合自定义的排序标准则将它们交换。遍历数列的工作是重复地进行直到没有元素再需要交换，就说该数列已经完成排序。遍历一遍冒一个泡（最大值或最小值确定）。
1.2 算法描述
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
1.3 代码展示
// 冒泡排序
public static void bubbleSort (int[] arr)
//双重循环
for (int i = 0; i < arr.length - 1; i++)
boolean isSwaped = false;
for (int j = 0; j < arr.length - i - 1; j++)
if (arr[j] > arr[j + 1])
swap(arr,j,j + 1);
isSwaped = true;
if (!isSwaped)
break;
2、堆排序（Heap Sort）
2.1 概念简述
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
2.2 算法描述
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
2.3 代码展示
//堆排序
public static void heapSort(int[] arr)
// 1.先将arr进行heapify调整为最大堆
// 从最后一个非叶子节点开始进行siftDown操作
for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--)
siftDown(arr,i,arr.length);
// 此时arr就被调整为最大堆
for (int i = arr.length - 1; i > 0; i--)
// arr[0]堆顶元素，就是当前堆的最大值
swap(arr,0,i);
siftDown(arr,0,i);
/**
* 元素下沉操作
* @param arr 数组
* @param i 当前要下沉的元素
* @param length 数组长度
*/
private static void siftDown(int[] arr, int i, int length)
// 当前下沉元素的子节点要小于数组长度
while (2 * i + 1 < length)
int j = (i << 1) + 1; //j存放左子节点
if (j + 1 < length && arr[j + 1] > arr[j])
j = j + 1;
// j就是左右子树的最大值
if (arr[i] > arr[j])
//下沉结束
break;
else
swap(arr,i,j);
i = j;
private static void swap(int[] arr, int i, int j)
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
3、选择排序 (Selection Sort)
3.1 概念简述
选择排序是表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不额外占用内存空间。理论上讲，选择排序可能也是大部分人选择的排序方法了吧。
选择排序(Selection Sort)是一种简单直观的排序算法。它的工作原理：在未排序区间中找到最小(大)元素，存放到排序序列的起始位置，然后，再从剩余未排序区间中继续寻找最小(大)元素，然后放到已排序区间的末尾。重复上述操作，直到元素全部排序。
3.2 算法描述
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趟结束，数组有序化了。
3.3 代码展示
public static void selectionSort(int[] arr)
//最开始，无序区间[0……n] 有序区间[]
//当无序区间只剩下一个元素时，整个集合已经有序
for (int i = 0; i < arr.length; i++)
//min变量存储了当前的最小值索引
int min = i;
//从剩下的元素中选择最小值
for (int j = i + 1; j < arr.length; j++)
if (arr[j] < arr[min])
min = j;
//min索引一定对应了当前无序区间中找到的最小值索引，换到无序区间最前面i
swap(arr,min,i);
4、插入排序（Insertion Sort）
4.1 概念简述
插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
4.2 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经有序；
- 取出已排序区间的下一个元素即未排序区间的首元素，已排序区间从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
4.3 代码展示
//直接插入排序
//每次从无序区间中拿出第一个值插入到已经排序区间的合适位置，直到整个数组有序
public static void insertionSort(int[] arr)
//已排序区间[0,i)
//无序区间[i,n]
for (int i = 1; i < arr.length; i++)
// //待排序区间的第一个元素arr[i]
// //从待排序区间的第一个元素向前看，找到合适的插入位置
// for (int j = i; j > 0; j--)
// //arr[j - 1]已排序区间的最后一个元素
// if (arr[j] >= arr[j - 1])
// //相等的话不交换，保证稳定性
// //此时说明arr[j] > 已排序区间的最大值，arr[j] 已经有序~直接下次循环
// break;
// else
// swap(arr,j,j - 1);
//
//
for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--)
swap(arr,j,j - 1);
5、希尔排序（Shell Sort）
5.1 概念简述
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
5.2 算法描述
希尔排序的基本步骤，在此我们选择增量 gap=length/2，缩小增量继续以 gap = gap/2 的方式，这种增量选择我们可以用一个序列来表示，n/2,(n/2)/2...1，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中 ti>tj ，tk=1；
- 按增量序列个数 k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
5.3 代码展示
public static void shellSort(int[] arr)
int gap = arr.length >> 1;
while (gap > 1)
//预处理阶段
insertionSortByGap(arr,gap);
gap = gap >> 1;
//此时gap等于1，整个集合已经接近有序，只需要全集合来一次插入排序即可
insertionSort(arr);
6、归并排序 （Merge Sort）
6.1 概念简述
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
6.2 算法描述
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
6.3 代码展示
public static void mergeSort(int[] arr)
mergeSortInternal(arr,0,arr.length - 1);
/**
* 在arr[l...r]进行归并排序,整个arr经过函数后就是一个已经有序的数组
* @param arr
* @param l
* @param r
*/
private static void mergeSortInternal(int[] arr, int l, int r)
if (r - l <= 15)
// 2.小区间直接使用插入排序
insertionSort(arr,l,r);
return;
int mid = l + ((r - l) >> 1);
// 将原数组拆分为左右两个小区间，分别递归进行归并排序
// 走完这个函数之后 arr[l..mid]已经有序
mergeSortInternal(arr,l,mid);
// 走完这个函数之后 arr[mid + 1..r]已经有序
mergeSortInternal(arr,mid + 1,r);
// 1.只有左右两个子区间还有先后顺序不同时才merge
if (arr[mid] > arr[mid + 1])
merge(arr,l,mid,r);
/**
* 在arr[l..r]使用插入排序
* @param arr
* @param l
* @param r
*/
private static void insertionSort(int[] arr, int l, int r)
for (int i = l + 1; i <= r; i++)
for (int j = i; j > l && arr[j] < arr[j - 1]; j--)
swap(arr,j,j - 1);
/**
* 合并两个子数组arr[l..mid] 和 arr[mid + 1...r]
* 为一个大的有序数组arr[l...r]
* @param arr
* @param l
* @param mid
* @param r
*/
private static void merge(int[] arr, int l, int mid, int r)
// 先创建一个新的临时数组aux
int[] aux = new int[r - l + 1];
// 将arr元素值拷贝到aux上
for (int i = 0; i < aux.length; i++)
aux[i] = arr[i + l];
// i就是左侧小数组的开始索引
int i = l;
// j就是右侧小数组的开始索引
int j = mid + 1;
// k表示当前正在合并的原数组的索引下标
for (int k = l; k <= r; k++)
if (i > mid)
// 左侧区间已经被处理完毕，只需要将右侧区间的值拷贝原数组即可
arr[k] = aux[j - l];
j ++;
else if (j > r)
// 右侧区间已经被处理完毕，只需要将左侧区间的值拷贝到原数组即可
arr[k] = aux[i - l];
i ++;
else if (aux[i - l] <= aux[j - l])
// 此时左侧区间的元素值较小，相等元素放在左区间，保证稳定性
arr[k] = aux[i - l];
i ++;
else
// 右侧区间的元素值较小
arr[k] = aux[j - l];
j ++;
7、快速排序（Quick Sort）
7.1 概念简述
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
7.2 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
7.3 代码展示
public static void quickSort(int[] arr)
quickSortInternal(arr,0,arr.length - 1);
/**
* 在arr[l,r]上进行快速排序
* @param arr
* @param l
* @param r
*/
private static void quickSortInternal(int[] arr, int l, int r)
if (r - l <= 15)
insertionSort(arr, l, r);
return;
//先获取分区点
//所谓的分区点就是经过分区函数后，某个元素落在了最终的位置
//分区点左侧全都是小于该元素的区间，分区点右侧全都是 >= 该元素的区间
int p = partition(arr,l,r);
//在左区间和右区间上重复上述流程
quickSortInternal(arr,l,p - 1);
quickSortInternal(arr,p + 1,r);
/**
* 在 arr[l,r] 上的分区函数，返回分区点的索引
* @param arr
* @param l
* @param r
* @return
*/
private static int partition(int[] arr, int l, int r)
//随机在当前数组中选一个数
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int v = arr[l];
// arr[l + 1..j] < v
// arr[j + 1..i) >= v
// i表示当前正在扫描的元素
int j = l;
for (int i = l + 1; i <= r; i++)
if (arr[i] < v)
swap(arr,j + 1,i);
j ++;
//将基准值和最后一个 < v 的元素交换，基准值就落在了最终位置
swap(arr, l, j);
return j;
本小节完^_^
以上是关于七大排序基本实现——Java的主要内容，如果未能解决你的问题，请参考以下文章