堆排序

堆排序算法

一、堆排序算法的基本特性
时间复杂度：O（n*lgn）
最坏：O（n*lgn）
空间复杂度：O（1）
不稳定。

堆排序是一种选择排序算法，与关键字的初始排列次序无关，即就是在最好，最坏，一般的情况下排序时间复杂度不变。对包含n个数的输入数组，平均时间为O（nlgn），最坏情况（已经排好序）也是是O（nlgn），最好情况（完全无序）也是O（nlgn）。由于不但时间复杂度少，而且空间复杂度也是最少的，所以是用于排序的最佳选择。因为，基于比较的排序，最快也只能达到O（nlgn），虽然快排也可以达到这个这个水平，但是快排的时间复杂度是跟关键字的初始排序有关，最坏的情况退化成O(n^2)，而且快排的空间复杂度是O（n*lgn）。

二、堆排序详解

三、堆排序

import java.util.*;
public class HeapSort{

  //堆排序
  public static void heapSort(int[] arr){
    for(int i = arr.length; i > 0; i--)
    {
        max_heapify(arr, i);
        //堆顶元素(第一个元素)与Kn交换
        swap(arr,0,i-1);
    }
    //输出排序后的结果
    System.out.println(Arrays.toString(arr));
}

 //堆调整
 private static void max_heapify(int[] arr, int limit){
    if(arr.length <= 0 || arr.length < limit) return;
    int parentIdx = limit / 2;

    for(; parentIdx >= 0; parentIdx--)
    {
        if(parentIdx * 2 >= limit)
        {
            continue;
        }
        int left = parentIdx * 2;       //左子节点位置
        int right = (left + 1) >= limit ? left : (left + 1);    //右子节点位置，如果没有右节点，默认为左节点位置

        int maxChildId = arr[left] >= arr[right] ? left : right;
        if(arr[maxChildId] > arr[parentIdx])
        {   //交换父节点与左右子节点中的最大值
            int temp = arr[parentIdx];
            arr[parentIdx] = arr[maxChildId];
            arr[maxChildId] = temp;
        }
    }
    //堆的调整每次的输出结果
    //System.out.println("Max_Heapify: " + Arrays.toString(arr));
}

//值的交换
public static void swap(int[]arr,int index1,int index2)
{
    int temp = arr[index1];     
    arr[index1] = arr[index2];
    arr[index2] = temp;
}
   public static void main(String []args)
   {
      int[]arr={70,60,12,40,30,8,10};
      heapSort(arr);
   }

}