java heapsort_Java HeapSort

/**

*

*

*

Copyright 1994-2018 JasonInternational

*

All rights reserved.

*

Created on 2018年4月10日

*

Created by Jason

*

*

*/

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.

*

* Family: Selection.

* Space: In-place.

* Stable: False.

*

* Average case = O(n*log n)

* Worst case = O(n*log n)

* Best case = O(n*log n)

*

* @see Heap Sort (Wikipedia)

*

* @author Justin Wetherell

*/

public class HeapSort> {

private HeapSort() { }

public static > T[] sort(T[] unsorted) {

createHeap(unsorted);

sortHeap(unsorted);

return unsorted;

}

private static > 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 > 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 > 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 > void swap(int parentIndex, int childIndex, T[] unsorted) {

T parent = unsorted[parentIndex];

unsorted[parentIndex] = unsorted[childIndex];

unsorted[childIndex] = parent;

}

}