堆排序的java实现

堆排序时间的复杂度为N lgN，空间复杂度为常量，没有很深的调用堆栈，是本人比较偏好的一种排序方法，堆排序的一般步骤是：

1 创建堆

2 不断取出根元素重建堆

 

package heapsort;

import java.util.Random;

 

public class HeapSort{
 public static void sort(Comparable[] array) {
  for (int i = 1; i < array.length; i++) {
   makeHeap(array, i);
  }
  
  
  
       
      for (int i = array.length-1; i > 0; i--)  {
       Comparable temp = array[i];
       array[i] = array[0];
       array[0] = temp;
       rebuildHeap(array, i);
      }
 }
 
 // 把 array[k-1]看成一个堆 ， 把添加到队中

 private static void makeHeap(Comparable[] array,int k) {
  int current = k;
  while (current > 0 && array[current].compareTo(array[(current-1)/2]) >0 ) {
   Comparable temp = array[current];
   array[current] = array[(current-1)/2];
   array[(current-1)/2] = temp;
   current = (current-1)/2;
  }
  
 }
 
 //堆的根元素已删除，末尾元素已移到根位置，开始重建
 public static void rebuildHeap(Comparable[] array, int size) {
  int currentIndex = 0;
  int right = currentIndex * 2 + 2;
  int left = currentIndex * 2 + 1;
  int maxIndex = currentIndex;
  boolean isHeap = false;
  while (!isHeap) {
   if (left < size && array[currentIndex].compareTo(array[left]) < 0) {
    maxIndex = left;
   }
   if (right < size && array[maxIndex].compareTo(array[right]) < 0) {
    maxIndex = right;
   }
   if (currentIndex == maxIndex) {
    isHeap = true;
   } else {
    Comparable temp = array[currentIndex];
    array[currentIndex] = array[maxIndex];
    array[maxIndex] = temp;
    currentIndex = maxIndex;
    right = currentIndex * 2 + 2;
       left = currentIndex * 2 + 1;
   }
  }
  
  
  
 }
 
 public static void main(String[] args) {
  Random random = new Random();
  int len = 200;
        Integer[] arrInteger = new Integer[len];
        for (int i = 0; i < arrInteger.length; i++) {
         arrInteger[i] = random.nextInt(200);
         System.out.print(arrInteger[i]+"\t");
        }
        System.out.print("\n");
       
        Integer[] mmInteger  = new Integer[len];
        System.arraycopy(arrInteger, 0, mmInteger, 0, len);
       
        long start = System.nanoTime();
        sort(arrInteger);
        long end = System.nanoTime();
        System.out.println("time use" + (end  - start));
       
         start = System.nanoTime();
         for (int i = 0; i <mmInteger.length; i++) {
          for (int j = 0; j < mmInteger.length-i-1; j++) {
    if (mmInteger[j].compareTo(mmInteger[j+1]) >0) {
     Integer temp = mmInteger[j];
     mmInteger[j] = mmInteger[j+1];
     mmInteger[j+1] = temp;
    }
   }
         }
         end = System.nanoTime();
        System.out.println("Quick sort time use" + (end  - start));
       
       
        System.out.println("排序后");
        for (Integer integer : arrInteger) {
         System.out.print(integer+"\t");
        }
        System.out.print("\n");
        for (Integer integer : mmInteger) {
         System.out.print(integer+"\t");
        }
        System.out.print("\n");
 }
}