堆排序（2）

//构建大顶堆，依次取出堆顶值（最大值），即可有序排列
//该算法需要一个顶堆数据结构,排列的结果会改变相同值的相对顺序

 class HeapSort2 {
    public static void main(String[] args)
    {
        int[] heap=createHeap(new int[]{5, 2, 7, 3, 6, 1, 4, 6});
        sort(heap,0);
        println(heap);
    }

    private static void println(int[] arr)
    {
        for (int i : arr) {
            System.out.print(" "+i);
        }
        System.out.println();
    }
    private static int[] createHeap(int[] randomArray)
    {
        int[] heap=new int[randomArray.length];

        for(int index=0;index<randomArray.length;index++)
        {
            addElement(heap,index-1,randomArray[index]);
        }
        return heap;
    }

    private static void addElement(int[] src,int lastIndex,int element)
    {
        src[++lastIndex]=element;
        int parentIndex=lastIndex;
        int currentIndex=lastIndex;
        while (currentIndex>0)
        {
            parentIndex=(lastIndex-1)/2;
            int parentValue=src[parentIndex];
            //大的向上冒泡
            if(element>parentValue)
            {
                src[parentIndex]=element;
                src[currentIndex]=parentValue;
                currentIndex=parentIndex;
            }else break;
        }
    }

    private static void sort(int [] src,int poppedCount)
    {
       if (poppedCount<src.length)
        {
            poppedCount++;
            int ele=src[0];
            int lastIndex=src.length-poppedCount;
            //尾结点替换堆顶
            src[0]=src[lastIndex];
            src[lastIndex]=ele;

            //堆顶下沉
            int childIndex=0;
            int currentIndex=0;
            lastIndex=lastIndex-1;
            while (currentIndex<=lastIndex) {
                int childIndexLeft = currentIndex * 2 + 1;
                if (childIndexLeft > lastIndex)
                    break;

                int childIndexRight = currentIndex * 2 + 2;

                int childLeftValue = src[childIndexLeft];
                int desChildIndex=childIndexLeft;
                int desChildValue =childLeftValue;
                if (childIndexRight <= lastIndex)
                {
                    int childRightValue = src[childIndexRight];
                    if(childLeftValue < childRightValue)
                    {
                        desChildIndex =childIndexRight;
                        desChildValue =childRightValue;
                    }
                }

                int parentValue = src[currentIndex];
                //下沉
                if (parentValue != Math.max(parentValue, desChildValue)) {

                    src[desChildIndex] = parentValue;
                    src[currentIndex] = desChildValue;
                    currentIndex = desChildIndex;

                } else break;
            }
            sort(src,poppedCount);
        }

    }

}