Java算法--堆排序

package arithmetic;

import breeze.stats.distributions.Rand;

import java.util.Collections;
import java.util.Random;

public class HeapSort {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6,21,24,546,65,34,65,768,9,5,2,3,5,6,344,32,12,14, 7, 8, 9};
        shuffle(arr);
        sort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    private static void shuffle(int[] arr) {
        for (int i : arr) {
            int i1 = (int) (Math.random() * (arr.length));
            int i2 = (int) (Math.random() * (arr.length));
            swap(arr, i1, i2);
        }
    }

    public static void sort(int[] arr) {
        //1.变大根堆
        bigHeap(arr);
        //sort
        int heapsize = arr.length - 1;
        while (heapsize > 0) {
            //remove top
            swap(arr, heapsize, 0);
            heapsize--;
            goBottom(arr, heapsize, 0);
        }
    }

    private static void goBottom(int[] arr, int heapsize, int currentIndex) {
        int left = (currentIndex * 2 + 1);
        if (left > heapsize) return;

        int right = left + 1;
        int largest = right < heapsize && arr[right] > arr[left] ? right : left;
        largest = arr[largest]>arr[currentIndex]?largest:currentIndex;

        if(largest == currentIndex)return;

        swap(arr,largest,currentIndex);

        goBottom(arr,heapsize,largest);
    }

    private static void bigHeap(int[] arr) {
        int heapSize = 0;
        while (heapSize < arr.length - 1) {
            heapSize++;
            goTop(arr, heapSize);
        }
    }

    private static void goTop(int[] arr, int changeIndex) {
        int parentIndex = (changeIndex - 1) / 2;
        if (arr[parentIndex] < arr[changeIndex]) {
            swap(arr, parentIndex, changeIndex);
            goTop(arr, parentIndex);
        }
    }

    private static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}