十大经典排序算法Java实现（代码详细注释）
文章目录
- 各算法比较
- 1.冒泡排序
- 2.选择排序
- 3.插入排序
- 4.快速排序
- 5.希尔排序
- 6.计数排序
- 7.归并排序
- 8.基数排序
- 9.堆排序
- 10.桶排序
- 附：完整源代码
各算法比较
图片名词解释：
n: 数据规模
k: “桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存
稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
时间复杂度： 一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。
1.冒泡排序
/**
* 冒泡排序:
* 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列;
* 一次比较两个元素,如果它们的顺序错误就把它们交换过来;
* 走访数列的工作是重复的进行,直到没有再需要交换的元素，也就是说该数列已经排序完成。
* @param sortArray
* @return
*/
public static int[] bubbleSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=0;i<sortArray.length;i++){//每一趟排序从头开始两两比较进行交换，将最大或者最小的元素放到数组末尾已经有序的序列中，需要排序的总趟数等于数组的长度
boolean is_swap = false;//标志本趟排序中是否发生了交换，若没有发生交换则说明序列已经有序，可以直接结束排序
for(int j=0;j<sortArray.length-1-i;j++){//每次从头开始进行两两比较，第i趟排序则表示数组后面的i个元素已经有序，所以j
if(sortArray[j]>sortArray[j+1]){//每趟排序将最大的元素放到数组末尾，也就是升序排序
int temp = sortArray[j];
sortArray[j] = sortArray[j+1];
sortArray[j+1] = temp;
is_swap = true;
}
}
if(!is_swap){//本趟排序没有发生元素交换则整个序列已经有序，直接结束
break;
}
}
return sortArray;
}
2.选择排序
/**
* 选择排序:
* 选择排序是一种简单直观的排序算法。
* 首先在未排序序列中找到最小（大）元素，存放到已排序序列的起始位置;
* 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
* 以此类推，直到所有元素均排序完毕。
* @param sortArray
* @return
*/
public static int[] selectionSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=0;i<sortArray.length;i++){//每一趟排序寻找一个最小的元素放到数组开头已经有序的序列中，排序的总趟数为数组的长度
int minIndex = i;//本趟排序寻找的的最小元素的索引，默认为i，i表示本趟排序最终寻找的最小元素应该插入的位置
for(int j=i+1;j<sortArray.length;j++){//第i趟排序说明数组开头的i个元素已经有序，所以寻找最小的元素时从第i+1个元素开始
if(sortArray[j]<sortArray[minIndex]){//元素的值比当前最小元素的值小时，更新本趟排序寻找的最小元素索引
minIndex = j;
}
}
if(minIndex!=i){//如果最小元素的索引不是i则交换索引为minIndex和i的两个元素
int temp = sortArray[i];
sortArray[i] = sortArray[minIndex];
sortArray[minIndex] = temp;
}
}
return sortArray;
}
3.插入排序
/**
* 插入排序:
* 插入排序是一种简单直观的排序算法。
* 它是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入,
* 在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
* @param sortArray
* @return
*/
public static int[] insertionSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=0;i<sortArray.length-1;i++){
//假设数组第一个元素是已排序序列，其余元素是未排序序列,所以需要扫描（或者说排序）的总次数是未排序序列的元素个数,即：sortArray.length-1。因此i应该小于sortArray.length-1
//i表示已排序序列的最后一个元素的索引，每次需要从i开始向前扫描
int index = i;//在已经排序的序列中扫描的索引,初始为已排序序列的最后一个元素的索引
int temp = sortArray[index+1];//未排序序列的第一个元素索引，随着排序的进行，未排序序列中的元素将会逐渐插入到已排序序列中，所以未排序序列会越来越短,即：未排序序列的第一个元素索引将会逐渐增大直到数组末尾
while(index>=0 && temp<sortArray[index]){//在已排序序列中从最后一个元素开始向前扫描，需要反复把已排序元素逐步向后挪位，直到找到最新元素应该插入的位置，然后结束
sortArray[index+1] = sortArray[index];
index--;
}
sortArray[index+1] = temp;//程序执行到这里已经找到了最新元素的插入位置：index+1，将最新元素temp插入该位置
}
return sortArray;
}
4.快速排序
/**
* 快速排序：
* 通过一趟排序将待排记录按照一个基准值分隔成独立的两部分，其中一部分记录的值均比另一部分的值小
* 对这两部分记录继续进行快速排序，以达到整个序列有序。
* @param sortArray
* @param start
* @param end
* @return
*/
public static int[] quickSort(int[] sortArray,int start,int end){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int index = partition(sortArray, start, end);
if(index>start){
quickSort(sortArray, start, index-1);
}
if(index<end){
quickSort(sortArray, index+1, end);
}
return sortArray;
}
/**
* 对待排序数组的指定范围按照基准值分隔成两个部分，其中一部分的值均比另一部分的值小，并且返回分隔基准值的索引位置
* @param sortArray
* @param start 开始范围
* @param end 结束范围
* @return
*/
public static int partition(int[] sortArray,int start,int end){
int benchmark_index = start+(int)((end-start+1)*Math.random());//选取的基准值索引，随机选取一个
int index = start;//分隔成的两个部分中左边部分的索引
swapArrayElement(sortArray, benchmark_index, end);//将基准值放到最后一个
for(int i=start;i<=end;i++){//循环遍历进行分隔，只需要将所有比基准值小的元素放到基准值的左边部分，那么右边部分就是比基准值大的所有元素
if(sortArray[i]<=sortArray[end]){//sortArray[end]就是基准值
//当前元素比基准值小，则需要将当前元素放到左边部分，
//当前元素等于基准值则表示已经分隔完毕，此时index指向的位置应该是基准值所在的位置，此时需要将基准值放到此位置，通过下面的交换来完成
if(i>index){//当前元素比基准值小并且当前元素的索引值比左边部分的索引大，则需要交换元素到左边部分，左边部分的范围应该是start——>index
//交换数组中两个索引对应的元素值
swapArrayElement(sortArray, index, i);
}
if(i<end){//增加左边部分的索引，若i=end则表示index当前是基准值所在的位置，不需要再自增
index++;
}
}
}
return index;
}
/**
* 交换数组中两个元素的值
* @param array
* @param i
* @param j
*/
public static void swapArrayElement(int[] array,int i,int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
5.希尔排序
/**
* 希尔排序：
* 希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
* 希尔排序是把记录按一定增量分组（例如：增量为5，那么索引为0,5,10，15....的这些元素为一组），对每组使用直接插入排序算法排序；
* 随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，所有元素被分成一组，算法便终止。
* @param sortArray
* @return
*/
public static int[] heerSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int increment = sortArray.length/2;//增量
while(increment>0){
for(int i=increment;i<sortArray.length;i++){//这里和直接插入排序区别在于：每次向前扫描和向后挪位的间隔元素由1个变为增量increment个
int index = i-increment;
int temp = sortArray[i];
while(index>=0 && temp<sortArray[index]){
sortArray[index+increment] = sortArray[index];
index -= increment;
}
sortArray[index+increment] = temp;
}
increment /= 2;//增量每次缩小一半
}
return sortArray;
}
6.计数排序
/**
* 计数排序：
* 计数排序使用一个额外的数组C对应存放待排序数组中每个元素的频数（出现的次数）。
* 然后根据数组C来将待排序数组的元素排到正确的位置，它只能对整数进行排序。
* @param sortArray
* @return
*/
public static int[] countingSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int min = sortArray[0];//待排数组最小值
int max = sortArray[0];//待排数组最大值
for(int i=0;i<sortArray.length;i++){//查找最小值和最大值
if(sortArray[i]<min){
min = sortArray[i];
}
if(sortArray[i]>max){
max = sortArray[i];
}
}
int[] rateArray = new int[max-min+1];//创建频数数组,大小为待排数组中数据出现的所有可能情况，也即是：max-min+1
Arrays.fill(rateArray,0);//全部填充为0
for(int i=0;i<sortArray.length;i++){//遍历待排数组，统计每个数字出现的次数,每个元素在频数数组中的相对位置为：元素值-最小值
rateArray[sortArray[i]-min]++;
}
int index = 0;
int index_rate = 0;
while(index_rate<rateArray.length){//依次取出所有已经排序的元素
if(rateArray[index_rate]!=0){
sortArray[index++] = min+index_rate;//通过相对位置恢复元素的本来值
rateArray[index_rate]--;
}else{
index_rate++;
}
}
return sortArray;
}
7.归并排序
/**
* 归并排序:
* 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序;
* 对于子序列递归采用归并排序，直到子序列元素个数为1
* @param sortArray
* @return
*/
public static int[] mergeSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
//将序列拆分为两个子序列
int mid = sortArray.length/2;
int[] left = Arrays.copyOfRange(sortArray, 0, mid);
int[] right = Arrays.copyOfRange(sortArray, mid, sortArray.length);
//合并两个两个子序列，对于两个子序列递归使用归并排序
return merge(mergeSort(left), mergeSort(right));
}
/**
* 将两个归并排序拆分的两个子序列合并为一个序列
* @param left
* @param right
* @return
*/
public static int[] merge(int[] left,int[] right){
int[] result = new int[left.length+right.length];//新建一个数组，大小为两个待合并的数组的长度之和，存放合并结果
for(int index=0,index_left=0,index_right=0;index<result.length;index++){//开始合并
if(index_left>=left.length){//左边的序列已经全部合并到了结果中，则直接将右边的序列合并到结果中
result[index] = right[index_right++];
}else if(index_right>=right.length){//右边的序列已经全部合并到了结果中，则直接将左边的序列合并到结果中
result[index] = left[index_left++];
}else if(left[index_left]<right[index_right]){//判断左边序列和右边序列当前要合并的元素的大小，保证合并的后的结果依然有序
result[index] = left[index_left++];
}else{
result[index] = right[index_right++];
}
}
return result;
}
8.基数排序
/**
* 基数排序：
* 基数排序是分别对每一位（个，十，百...）进行排序，
* 每次排序都在前一位已经排序的基础上进行，首先从最低位（个位）开始排序。
* @param sortArray
* @return
*/
public static int[] radixSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int max = sortArray[0];
for(int i=0;i<sortArray.length;i++){//取得待排数组中的最大值
if(sortArray[i]>max){
max = sortArray[i];
}
}
int maxDigit = 0;//最大值的位数
while(max!=0){//获取最大值的位数
max = max/10;
maxDigit++;
}
List<List<Integer>> bucket = new ArrayList<>();
for(int i=0;i<10;i++){//每一位只可能是0-9，所以只需要建立10个桶
bucket.add(new ArrayList<Integer>());
}
int mod = 10;
int div = 1;
for(int i=0;i<maxDigit;i++,mod*=10,div*=10){//从个位开始针对每一位的大小进行排序，直到最高位
for(int j=0;j<sortArray.length;j++){
int bucketIndex = (sortArray[j]%mod)/div;//获取数据映射的桶的索引，桶的索引就是数据在当前排序的位的值
bucket.get(bucketIndex).add(sortArray[j]);
}
int index = 0;
for(int m=0;m<bucket.size();m++){//收集本次的排序结果并清空桶，方便下一次的排序
for(int n=0;n<bucket.get(m).size();n++){
sortArray[index++] = bucket.get(m).get(n);
}
bucket.get(m).clear();
}
}
return sortArray;
}
9.堆排序
/**
* 堆排序：
* 利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足小（大）根堆的性质：即父结点的键值或索引总是小于（或者大于）等于它的子节点。
* 将所有待排序的元素序列构造大根堆，然后将根节点（此时根节点最大）与序列最后一个元素交换位置，此时最后一个元素最大，然后将最后一个元素剔除，也就是放到有序序列中。
* 针对剩下的元素不断重复上述步骤，直到剩下的元素为1
* @param sortArray
* @return
*/
public static int[] heapSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=sortArray.length/2-1;i>=0;i--){//从最后一个非叶子节点开始向上构造大根堆，最后一个非叶子节点的索引为sortArray.length/2-1
adjustHeap(sortArray, i, sortArray.length);
}
for(int j=sortArray.length-1;j>0;j--){//经过前面的构造，此时根节点已经是最大的元素
swapArrayElement(sortArray, 0, j);//将根节点和最后一个节点交换位置
adjustHeap(sortArray, 0, j);//对剩下的元素继续构造大根堆
}
return sortArray;
}
/**
* 调整该节点使之符合大根堆（该节点的值比左右孩子都大）
* @param array
* @param adjustNodeIndex 待调整的节点索引
* @param length 调整的范围
*/
public static void adjustHeap(int[] array,int adjustNodeIndex,int length){
int maxIndex = adjustNodeIndex;//最大元素的索引，默认为当前调整的节点索引
int leftIndex = 2*adjustNodeIndex+1;//当前节点的左孩子索引
int rightIndex = 2*adjustNodeIndex+2;//当前节点的右孩子索引
if(leftIndex<length && array[leftIndex]>array[maxIndex]){//若左孩子的值比最大元素大，则更新最大元素的索引
maxIndex = leftIndex;
}
if(rightIndex<length && array[rightIndex]>array[maxIndex]){//若右孩子的值比最大元素大，则更新最大元素的索引
maxIndex = rightIndex;
}
if(maxIndex!=adjustNodeIndex){//如果父节点不是最大值，调整父节点为最大值并且调整与父节点交换的节点符合大根堆
swapArrayElement(array, maxIndex, adjustNodeIndex);
adjustHeap(array, maxIndex, length);
}
}
/**
* 交换数组中两个元素的值
* @param array
* @param i
* @param j
*/
public static void swapArrayElement(int[] array,int i,int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
10.桶排序
/**
* 桶排序:
* 桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
* 桶排序 假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别使用别的排序算法排序。
* @param sortArray
* @param bucketSize
* @return
*/
public static int[] bucketSort(int[] sortArray,int bucketSize){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int min = sortArray[0];
int max = sortArray[0];
for(int i=0;i<sortArray.length;i++){
if(sortArray[i]<min){
min = sortArray[i];
}
if(sortArray[i]>max){
max = sortArray[i];
}
}
int bucketCount = (max-min)/bucketSize+1;//桶的个数
List<List<Integer>> bucket = new ArrayList<>();//每个桶是一个List
for(int i=0;i<bucketCount;i++){//初始化桶
bucket.add(new ArrayList<Integer>());
}
for(int i=0;i<sortArray.length;i++){//将数据放入每一个桶中
List<Integer> temp_bucket = bucket.get((sortArray[i]-min)/bucketSize);
temp_bucket.add(sortArray[i]);
}
int index = 0;
for(int i=0;i<bucketCount;i++){//遍历所有桶分别进行排序，然后将数据拼接起来
List<Integer> temp_bucket = bucket.get(i);
if(temp_bucket.size()>0){
int[] temp_bucket_array = new int[temp_bucket.size()];
for(int j=0;j<temp_bucket_array.length;j++){
temp_bucket_array[j] = temp_bucket.get(j);
}
quickSort(temp_bucket_array, 0, temp_bucket_array.length-1);//每个桶采用快速排序
for(int k=0;k<temp_bucket_array.length;k++){
sortArray[index] = temp_bucket_array[k];
index++;
}
}
}
return sortArray;
}
附：完整源代码
package cn.test.sort;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class SortUtils {
/**
* 冒泡排序:
* 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列;
* 一次比较两个元素,如果它们的顺序错误就把它们交换过来;
* 走访数列的工作是重复的进行,直到没有再需要交换的元素，也就是说该数列已经排序完成。
* @param sortArray
* @return
*/
public static int[] bubbleSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=0;i<sortArray.length;i++){//每一趟排序从头开始两两比较进行交换，将最大或者最小的元素放到数组末尾已经有序的序列中，需要排序的总趟数等于数组的长度
boolean is_swap = false;//标志本趟排序中是否发生了交换，若没有发生交换则说明序列已经有序，可以直接结束排序
for(int j=0;j<sortArray.length-1-i;j++){//每次从头开始进行两两比较，第i趟排序则表示数组后面的i个元素已经有序，所以j
if(sortArray[j]>sortArray[j+1]){//每趟排序将最大的元素放到数组末尾，也就是升序排序
int temp = sortArray[j];
sortArray[j] = sortArray[j+1];
sortArray[j+1] = temp;
is_swap = true;
}
}
if(!is_swap){//本趟排序没有发生元素交换则整个序列已经有序，直接结束
break;
}
}
return sortArray;
}
/**
* 选择排序:
* 选择排序是一种简单直观的排序算法。
* 首先在未排序序列中找到最小（大）元素，存放到已排序序列的起始位置;
* 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
* 以此类推，直到所有元素均排序完毕。
* @param sortArray
* @return
*/
public static int[] selectionSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=0;i<sortArray.length;i++){//每一趟排序寻找一个最小的元素放到数组开头已经有序的序列中，排序的总趟数为数组的长度
int minIndex = i;//本趟排序寻找的的最小元素的索引，默认为i，i表示本趟排序最终寻找的最小元素应该插入的位置
for(int j=i+1;j<sortArray.length;j++){//第i趟排序说明数组开头的i个元素已经有序，所以寻找最小的元素时从第i+1个元素开始
if(sortArray[j]<sortArray[minIndex]){//元素的值比当前最小元素的值小时，更新本趟排序寻找的最小元素索引
minIndex = j;
}
}
if(minIndex!=i){//如果最小元素的索引不是i则交换索引为minIndex和i的两个元素
int temp = sortArray[i];
sortArray[i] = sortArray[minIndex];
sortArray[minIndex] = temp;
}
}
return sortArray;
}
/**
* 插入排序:
* 插入排序是一种简单直观的排序算法。
* 它是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入,
* 在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
* @param sortArray
* @return
*/
public static int[] insertionSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=0;i<sortArray.length-1;i++){
//假设数组第一个元素是已排序序列，其余元素是未排序序列,所以需要扫描（或者说排序）的总次数是未排序序列的元素个数,即：sortArray.length-1。因此i应该小于sortArray.length-1
//i表示已排序序列的最后一个元素的索引，每次需要从i开始向前扫描
int index = i;//在已经排序的序列中扫描的索引,初始为已排序序列的最后一个元素的索引
int temp = sortArray[index+1];//未排序序列的第一个元素索引，随着排序的进行，未排序序列中的元素将会逐渐插入到已排序序列中，所以未排序序列会越来越短,即：未排序序列的第一个元素索引将会逐渐增大直到数组末尾
while(index>=0 && temp<sortArray[index]){//在已排序序列中从最后一个元素开始向前扫描，需要反复把已排序元素逐步向后挪位，直到找到最新元素应该插入的位置，然后结束
sortArray[index+1] = sortArray[index];
index--;
}
sortArray[index+1] = temp;//程序执行到这里已经找到了最新元素的插入位置：index+1，将最新元素temp插入该位置
}
return sortArray;
}
/**
* 希尔排序：
* 希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
* 希尔排序是把记录按一定增量分组（例如：增量为5，那么索引为0,5,10，15....的这些元素为一组），对每组使用直接插入排序算法排序；
* 随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，所有元素被分成一组，算法便终止。
* @param sortArray
* @return
*/
public static int[] heerSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int increment = sortArray.length/2;//增量
while(increment>0){
for(int i=increment;i<sortArray.length;i++){//这里和直接插入排序区别在于：每次向前扫描和向后挪位的间隔元素由1个变为增量increment个
int index = i-increment;
int temp = sortArray[i];
while(index>=0 && temp<sortArray[index]){
sortArray[index+increment] = sortArray[index];
index -= increment;
}
sortArray[index+increment] = temp;
}
increment /= 2;//增量每次缩小一半
}
return sortArray;
}
/**
* 归并排序:
* 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序;
* 对于子序列递归采用归并排序，直到子序列元素个数为1
* @param sortArray
* @return
*/
public static int[] mergeSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
//将序列拆分为两个子序列
int mid = sortArray.length/2;
int[] left = Arrays.copyOfRange(sortArray, 0, mid);
int[] right = Arrays.copyOfRange(sortArray, mid, sortArray.length);
//合并两个两个子序列，对于两个子序列递归使用归并排序
return merge(mergeSort(left), mergeSort(right));
}
/**
* 将两个归并排序拆分的两个子序列合并为一个序列
* @param left
* @param right
* @return
*/
public static int[] merge(int[] left,int[] right){
int[] result = new int[left.length+right.length];//新建一个数组，大小为两个待合并的数组的长度之和，存放合并结果
for(int index=0,index_left=0,index_right=0;index<result.length;index++){//开始合并
if(index_left>=left.length){//左边的序列已经全部合并到了结果中，则直接将右边的序列合并到结果中
result[index] = right[index_right++];
}else if(index_right>=right.length){//右边的序列已经全部合并到了结果中，则直接将左边的序列合并到结果中
result[index] = left[index_left++];
}else if(left[index_left]<right[index_right]){//判断左边序列和右边序列当前要合并的元素的大小，保证合并的后的结果依然有序
result[index] = left[index_left++];
}else{
result[index] = right[index_right++];
}
}
return result;
}
/**
* 快速排序：
* 通过一趟排序将待排记录按照一个基准值分隔成独立的两部分，其中一部分记录的值均比另一部分的值小
* 对这两部分记录继续进行快速排序，以达到整个序列有序。
* @param sortArray
* @param start
* @param end
* @return
*/
public static int[] quickSort(int[] sortArray,int start,int end){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int index = partition(sortArray, start, end);
if(index>start){
quickSort(sortArray, start, index-1);
}
if(index<end){
quickSort(sortArray, index+1, end);
}
return sortArray;
}
/**
* 对待排序数组的指定范围按照基准值分隔成两个部分，其中一部分的值均比另一部分的值小，并且返回分隔基准值的索引位置
* @param sortArray
* @param start 开始范围
* @param end 结束范围
* @return
*/
public static int partition(int[] sortArray,int start,int end){
int benchmark_index = start+(int)((end-start+1)*Math.random());//选取的基准值索引，随机选取一个
int index = start;//分隔成的两个部分中左边部分的索引
swapArrayElement(sortArray, benchmark_index, end);//将基准值放到最后一个
for(int i=start;i<=end;i++){//循环遍历进行分隔，只需要将所有比基准值小的元素放到基准值的左边部分，那么右边部分就是比基准值大的所有元素
if(sortArray[i]<=sortArray[end]){//sortArray[end]就是基准值
//当前元素比基准值小，则需要将当前元素放到左边部分，
//当前元素等于基准值则表示已经分隔完毕，此时index指向的位置应该是基准值所在的位置，此时需要将基准值放到此位置，通过下面的交换来完成
if(i>index){//当前元素比基准值小并且当前元素的索引值比左边部分的索引大，则需要交换元素到左边部分，左边部分的范围应该是start——>index
//交换数组中两个索引对应的元素值
swapArrayElement(sortArray, index, i);
}
if(i<end){//增加左边部分的索引，若i=end则表示index当前是基准值所在的位置，不需要再自增
index++;
}
}
}
return index;
}
/**
* 堆排序：
* 利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足小（大）根堆的性质：即父结点的键值或索引总是小于（或者大于）等于它的子节点。
* 将所有待排序的元素序列构造大根堆，然后将根节点（此时根节点最大）与序列最后一个元素交换位置，此时最后一个元素最大，然后将最后一个元素剔除，也就是放到有序序列中。
* 针对剩下的元素不断重复上述步骤，直到剩下的元素为1
* @param sortArray
* @return
*/
public static int[] heapSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
for(int i=sortArray.length/2-1;i>=0;i--){//从最后一个非叶子节点开始向上构造大根堆，最后一个非叶子节点的索引为sortArray.length/2-1
adjustHeap(sortArray, i, sortArray.length);
}
for(int j=sortArray.length-1;j>0;j--){//经过前面的构造，此时根节点已经是最大的元素
swapArrayElement(sortArray, 0, j);//将根节点和最后一个节点交换位置
adjustHeap(sortArray, 0, j);//对剩下的元素继续构造大根堆
}
return sortArray;
}
/**
* 调整该节点使之符合大根堆（该节点的值比左右孩子都大）
* @param array
* @param adjustNodeIndex 待调整的节点索引
* @param length 调整的范围
*/
public static void adjustHeap(int[] array,int adjustNodeIndex,int length){
int maxIndex = adjustNodeIndex;//最大元素的索引，默认为当前调整的节点索引
int leftIndex = 2*adjustNodeIndex+1;//当前节点的左孩子索引
int rightIndex = 2*adjustNodeIndex+2;//当前节点的右孩子索引
if(leftIndex<length && array[leftIndex]>array[maxIndex]){//若左孩子的值比最大元素大，则更新最大元素的索引
maxIndex = leftIndex;
}
if(rightIndex<length && array[rightIndex]>array[maxIndex]){//若右孩子的值比最大元素大，则更新最大元素的索引
maxIndex = rightIndex;
}
if(maxIndex!=adjustNodeIndex){//如果父节点不是最大值，调整父节点为最大值并且调整与父节点交换的节点符合大根堆
swapArrayElement(array, maxIndex, adjustNodeIndex);
adjustHeap(array, maxIndex, length);
}
}
/**
* 计数排序：
* 计数排序使用一个额外的数组C对应存放待排序数组中每个元素的频数（出现的次数）。
* 然后根据数组C来将待排序数组的元素排到正确的位置，它只能对整数进行排序。
* @param sortArray
* @return
*/
public static int[] countingSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int min = sortArray[0];//待排数组最小值
int max = sortArray[0];//待排数组最大值
for(int i=0;i<sortArray.length;i++){//查找最小值和最大值
if(sortArray[i]<min){
min = sortArray[i];
}
if(sortArray[i]>max){
max = sortArray[i];
}
}
int[] rateArray = new int[max-min+1];//创建频数数组,大小为待排数组中数据出现的所有可能情况，也即是：max-min+1
Arrays.fill(rateArray,0);//全部填充为0
for(int i=0;i<sortArray.length;i++){//遍历待排数组，统计每个数字出现的次数,每个元素在频数数组中的相对位置为：元素值-最小值
rateArray[sortArray[i]-min]++;
}
int index = 0;
int index_rate = 0;
while(index_rate<rateArray.length){//依次取出所有已经排序的元素
if(rateArray[index_rate]!=0){
sortArray[index++] = min+index_rate;//通过相对位置恢复元素的本来值
rateArray[index_rate]--;
}else{
index_rate++;
}
}
return sortArray;
}
/**
* 桶排序:
* 桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
* 桶排序 假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别使用别的排序算法排序。
* @param sortArray
* @param bucketSize
* @return
*/
public static int[] bucketSort(int[] sortArray,int bucketSize){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int min = sortArray[0];
int max = sortArray[0];
for(int i=0;i<sortArray.length;i++){
if(sortArray[i]<min){
min = sortArray[i];
}
if(sortArray[i]>max){
max = sortArray[i];
}
}
int bucketCount = (max-min)/bucketSize+1;//桶的个数
List<List<Integer>> bucket = new ArrayList<>();//每个桶是一个List
for(int i=0;i<bucketCount;i++){//初始化桶
bucket.add(new ArrayList<Integer>());
}
for(int i=0;i<sortArray.length;i++){//将数据放入每一个桶中
List<Integer> temp_bucket = bucket.get((sortArray[i]-min)/bucketSize);
temp_bucket.add(sortArray[i]);
}
int index = 0;
for(int i=0;i<bucketCount;i++){//遍历所有桶分别进行排序，然后将数据拼接起来
List<Integer> temp_bucket = bucket.get(i);
if(temp_bucket.size()>0){
int[] temp_bucket_array = new int[temp_bucket.size()];
for(int j=0;j<temp_bucket_array.length;j++){
temp_bucket_array[j] = temp_bucket.get(j);
}
quickSort(temp_bucket_array, 0, temp_bucket_array.length-1);//每个桶采用快速排序
for(int k=0;k<temp_bucket_array.length;k++){
sortArray[index] = temp_bucket_array[k];
index++;
}
}
}
return sortArray;
}
/**
* 基数排序：
* 基数排序是分别对每一位（个，十，百...）进行排序，
* 每次排序都在前一位已经排序的基础上进行，首先从最低位（个位）开始排序。
* @param sortArray
* @return
*/
public static int[] radixSort(int[] sortArray){
if(sortArray == null || sortArray.length<2){
return sortArray;
}
int max = sortArray[0];
for(int i=0;i<sortArray.length;i++){//取得待排数组中的最大值
if(sortArray[i]>max){
max = sortArray[i];
}
}
int maxDigit = 0;//最大值的位数
while(max!=0){//获取最大值的位数
max = max/10;
maxDigit++;
}
List<List<Integer>> bucket = new ArrayList<>();
for(int i=0;i<10;i++){//每一位只可能是0-9，所以只需要建立10个桶
bucket.add(new ArrayList<Integer>());
}
int mod = 10;
int div = 1;
for(int i=0;i<maxDigit;i++,mod*=10,div*=10){//从个位开始针对每一位的大小进行排序，直到最高位
for(int j=0;j<sortArray.length;j++){
int bucketIndex = (sortArray[j]%mod)/div;//获取数据映射的桶的索引，桶的索引就是数据在当前排序的位的值
bucket.get(bucketIndex).add(sortArray[j]);
}
int index = 0;
for(int m=0;m<bucket.size();m++){//收集本次的排序结果并清空桶，方便下一次的排序
for(int n=0;n<bucket.get(m).size();n++){
sortArray[index++] = bucket.get(m).get(n);
}
bucket.get(m).clear();
}
}
return sortArray;
}
/**
* 交换数组中两个元素的值
* @param array
* @param i
* @param j
*/
public static void swapArrayElement(int[] array,int i,int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
/**
* 打印数组
* @param array
*/
public static void PrintArray(int[] array){
StringBuilder sb = new StringBuilder("[");
for(int i=0;i<array.length;i++){
sb.append(array[i]);
if(i!=array.length-1){
sb.append(",");
}
}
sb.append("]");
System.out.println(sb);
}
public static void main(String[] args) {
int sortArray[] = new int[]{20,5,3,9,6,7,500,36,1,36,500,20};
bubbleSort(sortArray);
//selectionSort(sortArray);
//insertionSort(sortArray);
//heerSort(sortArray);
//sortArray = mergeSort(sortArray);
//quickSort(sortArray, 0, sortArray.length-1);
//heapSort(sortArray);
//countingSort(sortArray);
//bucketSort(sortArray, 50);
//radixSort(sortArray);
PrintArray(sortArray);
}
}