八大排序算法详解~~~
一、 排序算法的介绍和分类
排序算法的介绍
排序也称排序算法 (Sort Algorithm)，排序是将一 组数据，依指定的顺序进行排列的过程
排序算法的分类
- 内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序。
- 外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
常见的排序算法分类
二、算法的时间复杂度
计算时间复杂度的方法
计算时间复杂度的方法：
- 用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
- 修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
- 去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)
可以忽略常数项、忽略低次项、忽略系数
常见的时间复杂度
-
常数阶O(1)
无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)
-
对数阶O(log2n)
说明：在while循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。假设循环x次之后，i 就大于 2 了，此时这个循环就退出了，也就是说 2 的 x 次方等于 n，那么 x = log2n也就是说当循环 log2n 次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(log2n) 。 O(log2n) 的这个2 时间上是根据代码变化的，i = i * 3 ，则是 O(log3n)
-
线性阶O(n)
for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度
-
线性对数阶O(nlog2n)
线性对数阶O(nlogN) 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了O(nlogN)
-
平方阶O(n2)
-
立方阶O(n3)
-
k次方阶O(nk)
-
指数阶O(2^n)
常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜Ο(n^k)＜Ο(2n) < Ο(n!)，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低
三、冒泡排序
冒泡排序基本介绍
- 冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒
- 因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是进行过交换。从而减少不必要的比较
冒泡排序图解
冒泡排序规则小结：
- 一共进行数组的大小-1次大的循环
- 每一趟排序的次数在逐渐的减少
- 如果我们发现在某躺排序中，没有发生一次交换，可以提前结束冒泡排序
代码实现
初始版
/**冒泡排序
* @author cVzhanshi
* @create 2021-11-12 16:41
*/
public class BubbleSort {
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
//selectSort(data,data.length);
bubbleSort(data,data.length);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
private static void bubbleSort(int[] data,int len){
for(int i = 0;i < len - 1;i++){
for(int j = 0;j<len - 1 - i;j++){
if(data[j] > data[j+1]){
int temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
}
}
优化版
/**冒泡排序
* @author cVzhanshi
* @create 2021-11-12 16:41
*/
public class BubbleSort {
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
//selectSort(data,data.length);
bubbleSort(data,data.length);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
private static void bubbleSort(int[] data,int len){
boolean flag = false; // 标识变量，表示一躺排序是否进行交换
for(int i = 0;i < len - 1;i++){
for(int j = 0;j<len - 1 - i;j++){
if(data[j] > data[j+1]){
flag = true;
int temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
if(!flag){
break;
}else{
flag = false; // 重置flag ！！ 进行下一趟排序
}
}
}
}
四、选择排序
选择排序基本介绍
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的
选择排序思想
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]-arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]-arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]-arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列
图解选择排序
代码实现
普通版
/**
* 简单选择排序
* @author cVzhanshi
* @create 2021-11-04 15:39
*/
public class SelectSort {
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
//selectSort(data,data.length);
selectSort2(data,data.length);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
private static void selectSort(int[] data, int length) {
if(length == 0 || length == 1){
return;
}
for(int i = 0; i < length - 1 ;i++){
int index = i;
for(int j = i + 1;j < length;j++){
if(data[index] >= data[j]){
index = j;
}
}
if(index != i){
int temp = data[i];
data[i] = data[index];
data[index] = temp;
}
}
}
}
优化版
/**
* 二元选择排序
* @author cVzhanshi
* @create 2021-11-04 15:39
*/
public class SelectSort {
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
//selectSort(data,data.length);
selectSort2(data,data.length);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
/**
* 二元选择排序
* 每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可
* @param a
* @param len
*/
private static void selectSort2(int a[],int len) {
int i,j,min,max,tmp;
for(i=0; i<len/2; i++){
// 做不超过n/2趟选择排序
min = max = i;
for(j=i+1; j<=len-1-i; j++){
//分别记录最大和最小关键字记录位置
if(a[j] > a[max]){
max = j;
continue;
}
if(a[j] < a[min]){
min = j;
}
}
//该交换操作还可分情况讨论以提高效率
if(min != i){
//当第一个为min值，不用交换
tmp=a[min]; a[min]=a[i]; a[i]=tmp;
}
if(max == len-1-i && min == i)//当第一个为min值，同时最后一个为max值，不再需要下面操作
continue;
if(max == i)//当第一个为max值，则交换后min的位置为max值
max = min;
if(max != len-1-i){
//当最后一个为max值，不用交换
tmp=a[max]; a[max]=a[len-1-i]; a[len-1-i]=tmp;
}
}
}
}
五、插入排序
插入排序介绍
插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的
插入排序思想
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
插入排序图解
代码实现
/**
* 直接插入排序 时间复杂度：O（n^2）
* @author cVzhanshi
* @create 2021-11-03 17:32
*/
public class InsertSort {
public static void insertSort(int[] data){
if(data.length == 0 || data.length == 1)
return;
int length = data.length;
for(int i = 1;i < length; i++){
int temp = data[i];
if(data[i] < data[i - 1]){
int j = i - 1;
for(;j >= 0 && data[j] > temp; j--){
data[j + 1] = data[j];
}
data[j + 1] = temp;
}
System.out.println(Arrays.toString(data));
}
}
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
insertSort(data);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
}
六、希尔排序
小结插入排序：当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响
希尔排序介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序
希尔排序基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
图解希尔排序
代码实现
/**
* 希尔排序（插入排序）
* @author cVzhanshi
* @create 2021-11-04 14:42
*/
public class ShellSort {
/**
* 移动法
* @param data 待排序数组
* @param len 数组长度
* @param incr 增量
*/
public static void ShellInsertSort(int[] data,int len,int incr){
for(int i = incr;i < len;i++){
int temp = data[i];
if(data[i] < data[i - incr]){
int j = i - incr;
for(;j>=0 && data[j] > temp;j-=incr){
data[j + incr] = data[j];
}
data[j + incr] = temp;
}
}
}
/**
* 交换法
* @param data 待排序数组
* @param len 数组长度
* @param incr 增量
*/
public static void ShellInsertSortSwap(int[] data,int len,int incr){
int temp = 0;
for(int i = incr;i < len;i++){
int j = i - incr;
for(;j>=0 ;j-=incr){
// 如果当前元素大于加上步长后的那个元素，说明交换
if(data[j] > data[j + incr]){
temp = data[j];
data[j] = data[j + incr];
data[j + incr] = temp;
}
}
}
}
public static void ShellSort(int[] data,int len){
int incr = len/2;
while (incr >= 1){
ShellInsertSortSwap(data,len,incr);
incr /= 2;
}
}
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
ShellSort(data,data.length);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
}
七、快速排序
快速排序介绍
快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
快速排序图解
代码实现
/**
* 快速排序
* @author cVzhanshi
* @create 2021-11-12 17:02
*/
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if(start < end){
int base = data[start];
int i = start;
int j = end + 1;
while (true){
while (i < end && data[++i] <= base);
while (j > start && data[--j] >= base);
if(i < j){
swap(data , i , j);
}else{
break;
}
}
swap(data ,start,j);
subSort(data,start,j-1);
subSort(data,j+1,end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
//selectSort(data,data.length);
quickSort(data);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
}
八、归并排序
归并排序介绍
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)
归并排序图解
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤
代码实现
/**
* @author cVzhanshi
* @create 2021-11-15 20:00
*/
public class MergeSort {
public static void mergeSort(int[] data){
sort(data,0,data.length - 1);
}
// 将索引从left到right范围的数组元素进行归并排序
public static void sort(int[] data,int left,int right){
if(left < right){
// 找出中间索引
int center = (left + right) / 2;
sort(data, left , center);
sort(data,center + 1,right);
// 合并
merge(data,left , center , right);
}
}
// 将两个数组进行归并，归并前两个数组已经有序，归并后依然有序
public static void merge(int[] data,int left,int center,int right){
int[] tempArr = new int[data.length];
int mid = center + 1;
int third = left;
int temp = left;
while (left <= center && mid <= right) {
if(data[left] <= data[mid]){
tempArr[third++] = data[left++];
}else {
tempArr[third++] = data[mid++];
}
}
while (left <= center){
tempArr[third++] = data[left++];
}
while (mid <= left) {
tempArr[third++] = data[mid++];
}
while (temp <= right){
data[temp] = tempArr[temp++];
}
}
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
//selectSort(data,data.length);
mergeSort(data);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
}
九、基数排序
9.1 基数排序介绍
基数排序的介绍
- 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
- 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
- 基数排序(Radix Sort)是**桶排序**的扩展
- 基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较
基数排序基本思想
- 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列
- 负数解决思想： 将负数转换成0或正数，对所有数据同时加上最小值的绝对值
9.2 基数排序图解
第一轮排序
第二轮排序
第三轮排序
9.3 代码实现
将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序
初始版
/**
* 基数排序
* @author cVzhanshi
* @create 2021-11-16 17:12
*/
public class RadixSort {
public static void main(String[] args) {
int data[] = {
53, 3, 542, 748, 14, 214};
System.out.println("排序之前：\n" + Arrays.toString(data));
radixSort(data);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
private static void radixSort(int[] data) {
//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
//说明
//1. 二维数组包含10个一维数组
//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
//3. 基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][data.length];
//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
//可以这样理解
//比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
int[] bucketElementCounts = new int[10];
// 第一轮（针对每个元素的个位进行排序处理）
for(int j = 0;j < data.length;j++ ){
// 取出每个元素的个位的值
int digitOfElement = data[j] % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = data[j];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
int index = 0;
//遍历每一桶，并将桶中是数据，放入到原数组
for(int k = 0;k < bucketElementCounts.length;k++){
if(bucketElementCounts[k] != 0){
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入到data
data[index++] = bucket[k][l];
}
}
//第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！ 不然下一轮会出错
bucketElementCounts[k] = 0;
}
System.out.println("第1轮，对个位的排序处理 data =" + Arrays.toString(data));
// ==================================
// 第二轮（针对每个元素的十位进行排序处理）
for(int j = 0;j < data.length;j++ ){
// 取出每个元素的个位的值
int digitOfElement = data[j] / 10 % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = data[j];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
index = 0;
//遍历每一桶，并将桶中是数据，放入到原数组
for(int k = 0;k < bucketElementCounts.length;k++){
if(bucketElementCounts[k] != 0){
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入到data
data[index++] = bucket[k][l];
}
}
//第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！ 不然下一轮会出错
bucketElementCounts[k] = 0;
}
System.out.println("第2轮，对个位的排序处理 data =" + Arrays.toString(data));
// ==================================
// 第三轮（针对每个元素的百位进行排序处理）
for(int j = 0;j < data.length;j++ ){
// 取出每个元素的个位的值
int digitOfElement = data[j] / 100 % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = data[j];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
index = 0;
//遍历每一桶，并将桶中是数据，放入到原数组
for(int k = 0;k < bucketElementCounts.length;k++){
if(bucketElementCounts[k] != 0){
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入到data
data[index++] = bucket[k][l];
}
}
//第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！ 不然下一轮会出错
bucketElementCounts[k] = 0;
}
System.out.println("第3轮，对个位的排序处理 data =" + Arrays.toString(data));
}
}
结果和图解相对应
最终的基数排序代码（使用循环）
/**
* 基数排序
* @author cVzhanshi
* @create 2021-11-16 17:12
*/
public class RadixSort {
public static void main(String[] args) {
int data[] = {
53, 3, 542, 748, 14, 214};
System.out.println("排序之前：\n" + Arrays.toString(data));
radixSort(data);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
private static void radixSort(int[] data) {
//1. 得到数组中最大的数的位数
int max = data[0]; //假设第一数就是最大数
for(int i = 1; i < data.length; i++) {
if (data[i] > max) {
max = data[i];
}
}
//得到最大数是几位数
int maxLength = (max + "").length();
//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
//说明
//1. 二维数组包含10个一维数组
//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
//3. 基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][data.length];
//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
//可以这样理解
//比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
int[] bucketElementCounts = new int[10];
for(int i = 0 ,n = 1 ;i < maxLength;i++,n *= 10 ){
// 第i轮 (针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..）
for(int j = 0;j < data.length;j++){
// 取出每个元素的个位的值
int digitOfElement = data[j] / n % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = data[j];
bucketElementCounts[digitOfElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
int index = 0;
//遍历每一桶，并将桶中是数据，放入到原数组
for(int k = 0;k < bucketElementCounts.length;k++){
if(bucketElementCounts[k] != 0){
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入到data
data[index++] = bucket[k][l];
}
}
//第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！ 不然下一轮会出错
bucketElementCounts[k] = 0;
}
System.out.println("第"+ (i + 1) + "轮，对个位的排序处理 data =" + Arrays.toString(data));
}
}
}
注意事项
- 基数排序是对传统桶排序的扩展，速度很快.
- 基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError 。
- 基数排序是稳定的。[注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的]
十、堆排序
10.1 堆排序基本介绍
堆排序基本介绍
-
堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种**选择排序，**它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
-
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
-
每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
-
大顶堆举例说明
大顶堆特点：arr[i] >=arr[2*i+1] && arr[i] >=arr[2*i+2] //i 对应第几个节点，i从0开始编号
-
小顶堆举例说明
小顶堆特点：arr[i] <=arr[2*i+1] && arr[i] <=arr[2*i+2] //i 对应第几个节点，i从0开始编号
-
一般升序采用大顶堆，降序采用小顶堆
堆排序的基本思想
- 将待排序序列构造成一个大顶堆
- 此时，整个序列的最大值就是堆顶的根节点。
- 将其与末尾元素进行交换，此时末尾就为最大值。
- 然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
10.2 图解堆排序
图解堆排序
步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
-
假设给定无序序列结构如下
-
此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。
-
找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。
-
这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。
-
此时，我们就将一个无序序列构造成了一个大顶堆。
步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
-
将堆顶元素9和末尾元素4进行交换
-
重新调整结构，使其继续满足堆定义
-
再将堆顶元素8与末尾元素5进行交换，得到第二大元素8
-
后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序
小结堆排序的基本思路
- 将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
- 将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
- 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
10.3 代码实现
/**
* @author cVzhanshi
* @create 2021-11-16 11:28
*/
public class HeapSort {
public static void main(String[] args) {
int[] data = {
9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前：\n" + Arrays.toString(data));
heapSort(data);
System.out.println("排序之后：\n" + Arrays.toString(data));
}
// 编写一个堆排序的方法
public static void heapSort(int[] data){
int temp = 0;
//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
for(int i = data.length / 2 - 1;i >= 0;i--){
adjustHeap(data,i,data.length);
}
/**
* 2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
* 3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
*/
for(int j = data.length-1;j > 0; j--) {
//交换
temp = data[j];
data[j] = data[0];
data[0] = temp;
// 继续调整结构 为大顶堆
adjustHeap(data, 0, j);
}
}
// 将一个数组(完全二叉树),调整成一个大顶堆
/**
* 功能：完成 将以i对应的非叶子节点的树调整成大顶堆
* 举例 int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6}
* 如果我们再次调用 adjustHeap 传入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9,6,8,5, 4}
* @param data 待调整的数组
* @param i 表示非叶子节点在数组中的索引
* @param length 表示对多少个元素进行调整，length是在逐渐的减少
*/
public static void adjustHeap(int[] data,int i,int length){
// 先取出当前元素的值，保存在临时变量
int temp = data[i];
// 开始调整
for(int k = i * 2 + 1;k < length; k = k * 2 + 1){
if(k + 1 < length && data[k] < data[k + 1]){
k++;
}
if(data[k] > temp){
//如果子结点大于父结点
data[i] = data[k]; //把较大的值赋给当前结点
i = k; //!!! i 指向 k,继续循环比较
}else{
break;
}
}
//当for 循环结束后，我们已经将以i 为父结点的树的最大值，放在了 最顶(局部)
data[i] = temp;//将temp值放到调整后的位置
}
}
十一、常用排序算法总结与对比
- 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
- 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
- 内排序：所有排序操作都在内存中完成；
- 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
- 时间复杂度： 一个算法执行所耗费的时间。
- 空间复杂度：运行完一个程序所需内存的大小。
- n: 数据规模
- k: “桶”的个数
- In-place: 不占用额外内存
- Out-place: 占用额外内存