devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

图解八大排序算法——最详细的讲解_排序算法图解

作者：我家自动化 | 2024-04-15 23:42:06

赞

踩

排序算法图解

1.选择排序

1.1 动图演示

 

 

1.2 思路分析

1.  第一个跟后面的所有数相比，如果小于（或小于）第一个数的时候，暂存较小数的下标，第一趟结束后，将第一个数，与暂存的那个最小数进行交换，第一个数就是最小（或最大的数）

2.  下标移到第二位，第二个数跟后面的所有数相比，一趟下来，确定第二小（或第二大）的数

重复以上步骤

直到指针移到倒数第二位，确定倒数第二小（或倒数第二大）的数，那么最后一位也就确定了，排序完成。

 

1.3  负杂度分析

1.  不管原始数组是否有序，时间复杂度都是O（n2），

因为没一个数都要与其他数比较一次，（n-1）2次，分解：n2-2n+1,  去掉低次幂和常数，剩下n2,所以最后的时间复杂度是n2

2.  空间复杂度是O（1）,因为只定义了两个辅助变量，与n的大小无关，所以空间复杂度为O（1）

 1.4  Java 代码如下：

  1. import java.util.Arrays;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         int[] n = new int[]{1,6,3,8,33,27,66,9,7,88};
  5.         int temp,index = -1;
  6.         for (int i = 0; i < n.length-1; i++) {
  7.             index=i;
  8.             //如果大于，暂存较小的数的下标
  9.             for (int j = i+1; j <n.length; j++) {
  10.                 if(n[index]>n[j]){
  11.                     index = j;
  12.                 }
  13.             }
  14.             将一趟下来求出的最小数，与这个数交换
  15.             if(index>0){
  16.                 temp = n[i];
  17.                 n[i] = n[index];
  18.                 n[index] = temp;
  19.             }
  20.             System.out.println(Arrays.toString(n));
  21.         }
  22.         System.out.println(Arrays.toString(n));
  23.     }
  24. }

2. 冒泡排序

2.1  动图演示

 

2.2  思路分析

1.  相邻两个数两两相比，n[i]跟n[j+1]比，如果n[i]>n[j+1]，则将连个数进行交换，

2.  j++, 重复以上步骤，第一趟结束后，最大数就会被确定在最后一位，这就是冒泡排序又称大（小）数沉底，

3.  i++,重复以上步骤，直到i=n-1结束，排序完成。

 

2.3  负杂度分析

1.  不管原始数组是否有序，时间复杂度都是O（n2），

因为没一个数都要与其他数比较一次，（n-1）2次，分解：n2+2n-1,  去掉低次幂和常数，剩下n2,所以最后的时间复杂度是n2

2.  空间复杂度是O（1）,因为只定义了一个辅助变量，与n的大小无关，所以空间复杂度为O（1）

 

2.4  选择排序和冒泡排序的比较

1. 时间负责度都是O（n2）

2. 空间复杂度都是O（1）

3. 选择排序是从第一位开始确定最大或最小的数，保证前面的数都是有序的，且都比后面的数小或大，

　 冒泡排序是从最后一位开始确定最大或最小的数，保证后面的数都是有序的且都大于或小于前面的数。

 

2.5  Java 代码如下

  1. import java.util.Arrays;
  2. public class 冒泡 {
  3.     public static void main(String[] args) {
  4.         int[] n = new int[]{1,6,3,8,33,27,66,9,7,88};
  5.         int temp;
  6.         for (int i = 0; i < n.length-1; i++) {
  7.             for (int j = 0; j <n.length-1; j++) {
  8.                 if(n[j]>n[j+1]){
  9.                     temp = n[j];
  10.                     n[j] = n[j+1];
  11.                     n[j+1] = temp;
  12.                 }
  13.             }
  14.         }
  15.         System.out.println(Arrays.toString(n));
  16.     }
  17. }

3. 直接插入排序

3.1  动图演示

 

 

3.2  思路分析

例如从小到大排序:

1.  从第二位开始遍历，

2.  当前数（第一趟是第二位数）与前面的数依次比较，如果前面的数大于当前数，则将这个数放在当前数的位置上，当前数的下标-1，

3.  重复以上步骤，直到当前数不大于前面的某一个数为止，这时，将当前数，放到这个位置，

　　1-3步就是保证当前数的前面的数都是有序的，内层循环的目的就是将当前数插入到前面的有序序列里

4.  重复以上3步，直到遍历到最后一位数，并将最后一位数插入到合适的位置，插入排序结束。

 

根据思路分析，每一趟的执行流程如下图所示：

 

 

3.3  复杂度分析

1.  时间复杂度：插入算法，就是保证前面的序列是有序的，只需要把当前数插入前面的某一个位置即可。

     所以如果数组本来就是有序的，则数组的最好情况下时间复杂度为O（n）

     如果数组恰好是倒=倒序，比如原始数组是5 4 3 2 1，想要排成从小到大，则每一趟前面的数都要往后移，一共要执行n-1 + n-2 + … + 2 + 1 = n * (n-1) / 2 = 0.5 * n2 - 0.5 * n次，去掉低次幂及系数，所以最坏情况下时间复杂度为O（n2）

   平均时间复杂度(n+n2 )/2，所以平均时间复杂度为O（n2）

2.  空间复杂度：插入排序算法，只需要两个变量暂存当前数，以及下标，与n的大小无关，所以空间复杂度为：O（1）

 

3.4  Java 代码如下

  1. import java.util.Arrays;
  2. public class insertSort {
  3.     public static void main(String[] args) {
  4.         int[] n = new int[]{20,12,15,1,5,49,58,24,578,211,20,214,78,35,125,789,11};
  5.         int temp = 0,j;
  6.         for (int i = 1; i < n.length; i++) {
  7.             temp = n[i];
  8.             for (j = i; j >0; j--) {
  9.                 //如果当前数前面的数大于当前数，则把前面的数向后移一个位置
  10.                 if(n[j-1]>temp){
  11.                     n[j] = n[j-1];
  12.                     
  13.                     //第一个数已经移到第二个数，将当前数放到第一个位置，这一趟结束
  14.                     if(j==1){
  15.                         n[j-1] = temp;
  16.                         break;
  17.                     }
  18.  
  19.                 }else{//如果不大于，将当前数放到j的位置，这一趟结束
  20.                 
  21.                     n[j] = temp;
  22.                     break;
  23.                 }
  24.             }
  25.             System.out.println(Arrays.toString(n));
  26.         }
  27.         System.out.println(Arrays.toString(n));
  28.     }
  29. }

4. 快速排序

4.1  动图演示

 

 

4.2  思路分析

快速排序的思想就是，选一个数作为基数（这里我选的是第一个数），大于这个基数的放到右边，小于这个基数的放到左边，等于这个基数的数可以放到左边或右边，看自己习惯，这里我是放到了左边，

一趟结束后，将基数放到中间分隔的位置，第二趟将数组从基数的位置分成两半，分割后的两个的数组继续重复以上步骤，选基数，将小数放在基数左边，将大数放到基数的右边，在分割数组，，，直到数组不能再分为止，排序结束。

例如从小到大排序:

1.  第一趟，第一个数为基数temp，设置两个指针left = 0，right = n.length，

　　①从right开始与基数temp比较，如果n[right]>基数temp，则right指针向前移一位，继续与基数temp比较，直到不满足n[right]>基数temp

　　②将n[right]赋给n[left]

　　③从left开始与基数temp比较，如果n[left]<=基数temp，则left指针向后移一位，继续与基数temp比较，直到不满足n[left]<=基数temp

　　④将n[left]赋给n[rigth]

　　⑤重复①-④步，直到left==right结束，将基数temp赋给n[left]

2.  第二趟，将数组从中间分隔，每个数组再进行第1步的操作，然后再将分隔后的数组进行分隔再快排，

3.  递归重复分隔快排，直到数组不能再分，也就是只剩下一个元素的时候，结束递归，排序完成

根据思路分析，第一趟的执行流程如下图所示：

 

 

 

 

4.3  负杂度分析

1.  时间复杂度：

最坏情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)

这种情况时间复杂度就好计算了，就是冒泡排序的时间复杂度：T[n] = n * (n-1) = n^2 + n;

最好情况下是O(nlog2n)，推导过程如下：

（递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n)  ）

所以平均时间复杂度为O（nlog2n）

2.  空间复杂度：

　　快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据：

　　最优的情况下空间复杂度为:O(log2n)；每一次都平分数组的情况

　　最差的情况下空间复杂度为：O( n )；退化为冒泡排序的情况

所以平均空间复杂度为O（log2n）

 

 4.4  Java 代码如下

  1. import java.util.Arrays;
  2. public class quick{
  3.     public static void main(String[] args) {
  4.         int[] arr = new int[]{10,6,3,8,33,27,66,9,7,88};
  5.         f(arr,0,arr.length-1);
  6.         System.out.println(Arrays.toString(arr));
  7.     }
  8.     public static void f(int[] arr,int start,int end){
  9.         //直到start=end时结束递归
  10.         if(start<end){
  11.             int left = start;
  12.             int right = end;
  13.             int temp = arr[start];
  14.             
  15.             while(left<right){
  16.                 
  17.                 //右面的数字大于标准数时，右边的数的位置不变，指针向左移一个位置
  18.                 while(left<right && arr[right]>temp){
  19.                     right--;
  20.                 }
  21.                 
  22.                 //右边的数字小于或等于基本数，将右边的数放到左边
  23.                 arr[left] = arr[right];
  24.                 left++;
  25.                 左边的数字小于或等于标准数时，左边的数的位置不变，指针向右移一个位置
  26.                 while(left<right && arr[left]<=temp){
  27.                     left++;
  28.                 }
  29.                 
  30.                 //左边的数字大于基本数，将左边的数放到右边
  31.                 arr[right] = arr[left];
  32.             }
  33.             
  34.             //一趟循环结束，此时left=right，将基数放到这个重合的位置，
  35.             arr[left] = temp;
  36.             System.out.println(Arrays.toString(arr));
  37.             //将数组从left位置分为两半，继续递归下去进行排序
  38.             f(arr,start,left);
  39.             f(arr,left+1,end);
  40.         }
  41.     }
  42. }

5. 归并排序

5.1  动图演示

 

 

5.2  思路分析

归并排序就是递归得将原始数组递归对半分隔，直到不能再分（只剩下一个元素）后，开始从最小的数组向上归并排序

1.  向上归并排序的时候，需要一个暂存数组用来排序，

2.  将待合并的两个数组，从第一位开始比较，小的放到暂存数组，指针向后移，

3.  直到一个数组空，这时，不用判断哪个数组空了，直接将两个数组剩下的元素追加到暂存数组里，

4.  再将暂存数组排序后的元素放到原数组里，两个数组合成一个，这一趟结束。

根据思路分析，每一趟的执行流程如下图所示：

 

 

5.3  负杂度分析

1.  时间复杂度：递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n) 

无论原始数组是否是有序的，都要递归分隔并向上归并排序，所以时间复杂度始终是O（nlog2n）

2.  空间复杂度：

　　每次两个数组进行归并排序的时候，都会利用一个长度为n的数组作为辅助数组用于保存合并序列，所以空间复杂度为O（n）

 

 5.4  Java 代码如下

  1. import java.util.Arrays;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         int[] arr = new int[]{3,6,4,7,5,2};
  5.         merge(arr,0,arr.length-1);
  6.         System.out.println(Arrays.toString(arr));
  7.     }
  8.     
  9.     //归并
  10.     public static void merge(int[] arr,int low,int high){
  11.         int center = (high+low)/2;
  12.         if(low<high){
  13.             //递归，直到low==high，也就是数组已不能再分了，
  14.             merge(arr,low,center);
  15.             merge(arr,center+1,high);
  16.             
  17.             //当数组不能再分，开始归并排序
  18.             mergeSort(arr,low,center,high);
  19.             System.out.println(Arrays.toString(arr));
  20.         }
  21.     }
  22.     
  23.     //排序
  24.     public static void mergeSort(int[] arr,int low,int center,int high){
  25.         //用于暂存排序后的数组的临时数组
  26.         int[] tempArr = new int[arr.length];
  27.         int i = low,j = center+1;
  28.         
  29.         //临时数组的下标
  30.         int index = 0;
  31.         
  32.         //循环遍历两个数组的数字，将小的插入到临时数组里
  33.         while(i<=center && j<= high){
  34.             
  35.             //左边数组的数小，插入到新数组
  36.             if(arr[i]<arr[j]){
  37.                 tempArr[index] = arr[i];
  38.                 i++;
  39.             }else{//右边数组的数小，插入到新数组
  40.                 tempArr[index] = arr[j];
  41.                 j++;
  42.             }
  43.             index++;
  44.         }
  45.         
  46.         //处理左半边数组多余的数据，将左半边多余的数据直接追加的临时数组的后面
  47.         while(i<=center){
  48.             tempArr[index] = arr[i];
  49.             i++;
  50.             index++;
  51.         }
  52.         
  53.         //处理右半边数组多余的数据，将右半边多余的数据直接追加的临时数组的后面
  54.         while(j<= high){
  55.             tempArr[index] = arr[j];
  56.             j++;
  57.             index++;
  58.         }
  59.         
  60.         //将临时数组中的数据重新放进原数组
  61.         for (int k = 0; k < index; k++) {
  62.             arr[k+low] = tempArr[k];
  63.         }
  64.     }
  65. }

6. 基数排序

6.1  动图演示

 

 

6.2  思路分析

基数排序第i趟将待排数组里的每个数的i位数放到tempj（j=1-10）队列中，然后再从这十个队列中取出数据，重新放到原数组里，直到i大于待排数的最大位数。

1.数组里的数最大位数是n位，就需要排n趟，例如数组里最大的数是3位数，则需要排3趟。

2.若数组里共有m个数，则需要十个长度为m的数组tempj（j=0-9）用来暂存i位上数为j的数，例如，第1趟，各位数为0的会被分配到temp0数组里，各位数为1的会被分配到temp1数组里......

3.分配结束后，再依次从tempj数组中取出数据，遵循先进先进原则，例如对数组{1，11，2，44，4}，进行第1趟分配后，temp1={1,11}，temp2={2}，temp4={44，4}，依次取出元素后{1，11，2，44，4}，第一趟结束

4.循环到n趟后结束，排序完成

 

根据思路分析，每一趟的执行流程如下图所示：

通过基数排序对数组{53, 3, 542, 748, 14, 214, 154, 63, 616}：

 

 

6.3  负杂度分析

1.  时间复杂度：

每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。

假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。

系数2可以省略，且无论数组是否有序，都需要从个位排到最大位数，所以时间复杂度始终为O(d*n) 。其中，n是数组长度，d是最大位数。

2.  空间复杂度： 

　　基数排序的空间复杂度为O(n+k)，其中k为桶的数量，需要分配n个数。

 

6.4  Java 代码如下

  1. import java.util.Arrays;
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         int[] arr = new int[]{10,6,3,8,33,27,66,9,7,88};
  5.         radixSort(arr);
  6.     }
  7.  
  8.     private static void radixSort(int[] arr) {
  9.         //求出待排数的最大数
  10.         int maxLength=0;
  11.         for (int i = 0; i < arr.length; i++) {
  12.             if(maxLength<arr[i])
  13.                 maxLength = arr[i];
  14.         }
  15.         //根据最大数求最大长度
  16.         maxLength = (maxLength+"").length();
  17.  
  18.         //用于暂存数据的数组
  19.         int[][] temp = new int[10][arr.length];
  20.         //用于记录temp数组中每个桶内存的数据的数量
  21.         int[] counts = new int[10];
  22.         //用于记录每个数的i位数
  23.         int num = 0;
  24.         //用于取的元素需要放的位置
  25.         int index = 0;
  26.         //根据最大长度决定排序的次数
  27.         for (int i = 0,n=1; i < maxLength; i++,n*=10) {
  28.             for (int j = 0; j < arr.length; j++) {
  29.                 num = arr[j]/n%10;
  30.                 temp[num][counts[num]] = arr[j];
  31.                 counts[num]++;
  32.             }
  33.             
  34.             //从temp中取元素重新放到arr数组中
  35.             for (int j = 0; j < counts.length; j++) {
  36.                 for (int j2 = 0; j2 < counts[j]; j2++) {
  37.                     arr[index] = temp[j][j2];
  38.                     index++;
  39.                 }
  40.                 counts[j]=0;
  41.             }
  42.             index=0;
  43.         }
  44.         System.out.println(Arrays.toString(arr));
  45.     }
  46. }

复制代码

7. 希尔（shell）排序

7.1  动图演示

 

 

7.2  思路分析

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

　　简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。

　　而希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。

　　来看下希尔排序的基本步骤，在此选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处做示例使用希尔增量。

 

 

7.3  复杂度分析

1.  时间复杂度：最坏情况下，每两个数都要比较并交换一次，则最坏情况下的时间复杂度为O（n2）, 最好情况下，数组是有序的，不需要交换，只需要比较，则最好情况下的时间复杂度为O（n）。

经大量人研究，希尔排序的平均时间复杂度为O（n1.3）（这个我也不知道咋来的，书上和博客上都这样说，也没找到个具体的依据，，，）。

2.  空间复杂度：希尔排序，只需要一个变量用于两数交换，与n的大小无关，所以空间复杂度为：O（1）。

 

7.4  Java 代码如下

  1. import java.util.Arrays;
  2.  
  3. public class shell {
  4.     public static void main(String[] args) {
  5.         int[] arr = new int[]{10,6,3,8,33,27,66,9,7,88};
  6.         shellSort(arr);
  7.         System.out.println(Arrays.toString(arr));
  8.     }
  9.     private static void shellSort(int[] arr) {
  10.         int temp;
  11.         //控制增量序列,增量序列为1的时候为最后一趟
  12.         for (int i = arr.length/2; i >0; i/=2) {
  13.             //根据增量序列，找到每组比较序列的最后一个数的位置
  14.             for (int j = i; j < arr.length; j++) {
  15.                 //根据该比较序列的最后一个数的位置，依次向前执行插入排序
  16.                 for (int k = j-i; k >=0; k-=i) {
  17.                     if(arr[k]>arr[k+i]){
  18.                         temp = arr[k];
  19.                         arr[k]  = arr[k+i];
  20.                         arr[k+i] = temp;
  21.                     }
  22.                 }
  23.             }
  24.         }
  25.     }
  26. }

8. 堆排序

8.1  动图演示

 

 

8.2  思路分析

 

　　先来了解下堆的相关概念：堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]  

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]  

了解了这些定义。接下来看看堆排序的基本思想及基本步骤：

堆排序基本思想及步骤

　　堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了

步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

　　a.假设给定无序序列结构如下

2.此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

4.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

此时，我们就将一个无需序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

a.将堆顶元素9和末尾元素4进行交换

b.重新调整结构，使其继续满足堆定义

c.再将堆顶元素8与末尾元素5进行交换，得到第二大元素8.

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

再简单总结下堆排序的基本思路：

　　a.将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

　　b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

　　c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

 

8.3  复杂度分析

1.  时间复杂度：堆排序是一种选择排序，整体主要由构建初始堆+交换堆顶元素和末尾元素并重建堆两部分组成。其中构建初始堆经推导复杂度为O(n)，在交换并重建堆的过程中，需交换n-1次，而重建堆的过程中，根据完全二叉树的性质，[log2(n-1),log2(n-2)...1]逐步递减，近似为nlogn。所以堆排序时间复杂度最好和最坏情况下都是O(nlogn)级。

2.  空间复杂度：堆排序不要任何辅助数组，只需要一个辅助变量，所占空间是常数与n无关，所以空间复杂度为O(1)。

8.4  Java 代码如下

  1. import java.util.Arrays;
  2. public class duipaixu {
  3.     public static void main(String[] args) {
  4.         int[] arr = new int[]{4,6,8,5,9};
  5.         int length = arr.length;
  6.         //从最后一个非叶节点开始构建大顶堆
  7.         for (int i = arr.length/2-1; i >=0; i--) {
  8.             maximumHeap(i,arr,length);
  9.         }
  10.         //从最小的叶子节点开始与根节点进行交换并重新构建大顶堆
  11.         for (int i = arr.length-1; i >=0; i--) {
  12. //            System.out.println(Arrays.toString(arr));
  13.             swap(arr,0,i);
  14.             length--;
  15.             maximumHeap(0,arr,length);
  16.         }
  17.         System.out.println(Arrays.toString(arr));
  18.     }
  19.     //构建大顶堆
  20.     public static void maximumHeap(int i,int[] arr,int length){
  21.         int temp = arr[i];
  22.         for (int j = i*2+1; j < length; j=j*2+1) {
  23.             //如果右孩子大于做孩子，则指向右孩子
  24.             if(j+1<length && arr[j+1]>arr[j]){
  25.                 j++;
  26.             }
  27.             //如果最大的孩子大于当前节点，则将大孩子赋给当前节点，修改当前节点为其大孩子节点，再向下走。
  28.             if(arr[j]>temp){
  29.                 arr[i] = arr[j];
  30.                 i = j;
  31.             }else{
  32.                 break;
  33.             }
  34.         }
  35.         //将temp放到最终位置
  36.         arr[i] = temp;
  37.     }
  38.     //交换
  39.     public static void swap(int[] arr,int i,int j){
  40.         int temp = arr[i];
  41.         arr[i] = arr[j];
  42.         arr[j] = temp;
  43.     }
  44. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/430938
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号