最大堆的堆排序的Java实现

一.基本思想：
首先将所有元素（从未排过序的数组）插入堆中，然后从堆的根节点开始提取并且将最小的元素放到根节点然后堆化，直到完毕。

时间复杂度为O(nlogn).

二，排序代码如下：

//堆排序
int[] Heapsort(Heap h,int A[],int n)
{
    int i,temp;
    BuildHeap(h,A,n);
    h.count=n；
    for(i=n-1;i>=0;i--)
    {
        temp=h.array[0];
        A[i]=temp;
        h.array[0]=h.array[h.count-1];
        h.count--;
        h.PercolateDown(0);
    }
    return A;
}

完整代码如下：

Class Heap{
    public int[] array;//存储元素的数组
    public int count;//描述堆中存在元素的个数
    public int capacity;//堆的大小
    public int heap_type;//最大堆或最小堆
    //创建堆构造方法
    public Heap(int capacity,int heap_type)
    {
        this.capacity=capacity;
        this.heap_type=heap_type;
        this.count=0;
        this.array=new int[capacity];
    }
    //得到父母节点的位置
    public int Parent(int i)
    {
        if(i<=0||i>this.count)
            return -1;
        return (i-1)/2;
    }
    //得到左孩子节点的位置
    public int LeftChild(int i)
    {
        int left=2*i+1;
        if(left>=this.count)
            return -1;
        return left;
    }
    //得到右孩子节点的位置
    public int RightChild(int i)
    {
        int right=2*i+2;
        if(right>=this.count)
            return -1;
        return right;
    }
   //堆化元素
    public void PercolateDown(int i)
    {
        int l,r,max,temp;
        l=LeftChild(i);
        r=RightChild(i);
        if(l==-1&&r==-1)
            return;
        if(l!=-1&&this.array[l]>this.array[i])
            max=l;
        else
            max=i;
        if(r!=-1&&this.array[r]>this.array[max])
            max=r;

        if(max==i)
             return;
        else
        {
            temp=this.array[i];
            this.array[i]=this.array[max];
            this.array[max]=temp;
        }
        PercolateDown(max);
    }

   //扩展堆
   void ResizeHeap()
    {
        int []array_old=new int[this.capacity];
       System.arraycopy(this.array,0,array_old,0,this.count-1);//复制方法
        this.array=new int[this.capacity*2];
        if(this.array==null)
        {
            System.out.println("Memory Error");
            return;
        }
        for(int i=0;i<this.capacity;i++)
        {
            this.array[i]=array_old[i];

        }
        this.capacity *=2;
        array_old=null;

    }
   //数组建堆
    void BuildHeap(Heap h,int A[],int n)
    {
        if(h==null) return;
        while(n>this.capacity)
            h.ResizeHeap();

        for(int i=0;i<n;i++)//数组赋值
        {
            h.array[i]=A[i];

        }
        this.count=n;

        for(int i=(n-1)/2;i>=0;i--)//节点堆化
            h.PercolateDown(i);
    }

    //堆排序
    int[] Heapsort(Heap h,int A[],int n)
    {
        int i,temp;
        BuildHeap(h,A,n);
        h.count=n;

        for(i=n-1;i>=0;i--)
        {
            temp=h.array[0];
            A[i]=temp;
            h.array[0]=h.array[h.count-1];
            h.count--;
            h.PercolateDown(0);

        }
     
        return A;
    }
}

测试代码如下:

public class dui {
    public static void main(String[] args) {
        int a[]={13,17,1,6,4,2,5};
        Heap test=new Heap(a.length,0);
        a=test.Heapsort(test,a,a.length);
        for(int i=0;i<a.length;i++)
        {
            System.out.println(a[i]);
        }

    }
}

结果代码：