Java HeapSort

/**

 * <html>

 * <body>

 *  <P> Copyright 1994-2018 JasonInternational </p>

 *  <p> All rights reserved.</p>

 *  <p> Created on 2018年4月10日 </p>

 *  <p> Created by Jason</p>

 *  </body>

 * </html>

 */

package cn.ucaner.algorithm.sorts;

/**

 * Heapsort is a comparison-based sorting algorithm to create a sorted array (or

 * list), and is part of the selection sort family. Although somewhat slower in

 * practice on most machines than a well-implemented quicksort, it has the

 * advantage of a more favorable worst-case O(n log n) runtime.

 * <p>

 * Family: Selection.<br>

 * Space: In-place.<br>

 * Stable: False.<br>

 * <p>

 * Average case = O(n*log n)<br>

 * Worst case = O(n*log n)<br>

 * Best case = O(n*log n)<br>

 * <p>

 * @see <a href="https://en.wikipedia.org/wiki/Heap_sort">Heap Sort (Wikipedia)</a>

 * <br>

 * @author Justin Wetherell <phishman3579@gmail.com>

 */

public class HeapSort<T extends Comparable<T>> {

    private HeapSort() { }

    public static <T extends Comparable<T>> T[] sort(T[] unsorted) {

        createHeap(unsorted);

        sortHeap(unsorted);

        return unsorted;

    }

    private static <T extends Comparable<T>> void sortHeap(T[] unsorted) {

        int length = unsorted.length;

        for (int index = length - 1; index > 0; index--) {

            swap(0, index, unsorted); // swap root with the last heap element

            int i = 0; // index of the element being moved down the tree

            while (true) {

                int left = (i * 2) + 1;

                if (left >= index) // node has no left child

                    break;

                int right = left + 1;

                if (right >= index) { // node has a left child, but no right child

                    if (unsorted[left].compareTo(unsorted[i]) > 0)

                        swap(left, i, unsorted); // if left child is greater than node

                    break;

                }

                T ithElement = unsorted[i];

                T leftElement = unsorted[left];

                T rightElement = unsorted[right];

                if (ithElement.compareTo(leftElement) < 0) { // (left > i)

                    if (unsorted[left].compareTo(rightElement) > 0) { // (left > right)

                        swap(left, i, unsorted);

                        i = left;

                        continue;

                    }

                    // (left > i)

                    swap(right, i, unsorted);

                    i = right;

                    continue;

                }

                // (i > left)

                if (rightElement.compareTo(ithElement) > 0) {

                    swap(right, i, unsorted);

                    i = right;

                    continue;

                }

                // (n > left) & (n > right)

                break;

            }

        }

    }

    private static <T extends Comparable<T>> void createHeap(T[] unsorted) {

        // Creates a max heap

        int size = 0;

        int length = unsorted.length;

        for (int i = 0; i < length; i++) {

            T e = unsorted[i];

            size = add(size, e, unsorted);

        }

    }

    private static <T extends Comparable<T>> int add(int size, T element, T[] unsorted) {

        int length = size;

        int i = length;

        unsorted[length++] = element;

        T e = unsorted[i];

        int parentIndex = ((i - 1) / 2);

        T parent = unsorted[parentIndex];

        while (e.compareTo(parent) > 0) {

            swap(parentIndex, i, unsorted);

            i = parentIndex;

            e = unsorted[i];

            parentIndex = ((i - 1) / 2);

            parent = unsorted[parentIndex];

        }

        return length;

    }

    private static <T extends Comparable<T>> void swap(int parentIndex, int childIndex, T[] unsorted) {

        T parent = unsorted[parentIndex];

        unsorted[parentIndex] = unsorted[childIndex];

        unsorted[childIndex] = parent;

    }

}
巴特西

Java HeapSort

最新文章

热门文章
