java实现堆排序（从小到大排序）

package Paixu;
/*
父节点下标：（i-1）/2；
左孩子下标：i*2+1
右孩子下标：i*2+2

* 堆排序：1.维护堆 2.建堆 3.排序
*  维护堆前：
*   index: 0 1 2 3 4 5  6  7  8  9
*     num: 6 3 1 4 8 5  10 12 22 2
*  维护堆后
*   index: 0 1 2 3  4  5   6   7   8  9
 *    num: 22,12,10,6, 8, 5, 1, 3, 4, 2
* */

import java.util.Arrays;

public class Heapsort {
    public static void main(String[] args) {
        int []arr={6,3,1,4,8,5,10,12,22,2};
        heap_sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /*
     * 维护堆：在每次改变数组时调用，使其继续维持堆的特性
     * arr :目标数组
     * len :数组长度 (用于数组排序过程中，防止已排序的数字再次参与堆的维护)
     * i:当前处理的节点
     * */
    public static void heapify(int[] arr, int len, int i) {
        int largest = i;
        int lson = i * 2 + 1;
        int rson = i * 2 + 2;
        if(lson<len&&arr[largest]<arr[lson]){
            largest=lson;
        }
        if(rson<len&&arr[largest]<arr[rson]){
            largest=rson;
        }
        if(arr[largest]!=arr[i]){
            int temp=arr[largest];
            arr[largest]=arr[i];
            arr[i]=temp;
            heapify(arr,len,largest);
        }
    }
    /*
    * 堆排序入口
    * */
    public static void heap_sort(int []arr){
        //建堆
        int len=arr.length;
        for (int i = len/2-1; i >=0; i--) {
            heapify(arr,len,i);
        }
        System.out.println("建堆后："+Arrays.toString(arr));
        //排序
        while (len>0){
            //将堆顶元素移至末尾
            int temp=arr[0];
            arr[0]=arr[len-1];
            arr[len-1]=temp;
            len--;
            heapify(arr,len,0);
        }
    }
}