堆排序（java 语言实现）

package com.shan.heapSort;

public class Heap<E extends Comparable<E>> {
private java.util.ArrayList<E> list = new java.util.ArrayList<E>();

/** Create a default heap */
public Heap() {
}

/** Create a heap from an array of objects */
public Heap(E[] objects) {
for (int i = 0; i < objects.length; i++) {
add(objects[i]);
}
}

/** Add a new object into the heap */
public void add(E e) {
list.add(e); // Append to the heap
int currentIndex = list.size() - 1;

while (currentIndex > 0) {
int parentIndex = (currentIndex - 1) / 2;

E current = list.get(currentIndex);
E parent = list.get(parentIndex);

if (current.compareTo(parent) > 0) {
list.set(parentIndex, current);
list.set(currentIndex, parent);
currentIndex = parentIndex;
} else {
break; // the tree is a heap now
}
}

System.out.println(list);
}

/** Remove root from the heap */
public E remove() {
// if the Heap is empty return null
if (list.size() == 0)
return null;

// cached root(the first element of the list),
// and then replace it with the last element in the list
E removedOject = list.get(0);
list.set(0, list.get(list.size() - 1));
list.remove(list.size() - 1);

// find the proper place for the current element
int currentIndex = 0;
while (currentIndex < list.size()) {
int leftChildIndex = 2 * currentIndex + 1;
int rightChildIndex = 2 * currentIndex + 2;

// Find the max between the tow child
if (leftChildIndex >= list.size()) // the tree is a heap
break;

int maxIndex = leftChildIndex;
if (rightChildIndex < list.size()) {
if (list.get(maxIndex).compareTo(list.get(rightChildIndex)) < 0) {
maxIndex = rightChildIndex;
}
}

// Swap if the current node is less then the maximum
E current = list.get(currentIndex);
E maxChild = list.get(maxIndex);
if (current.compareTo(maxChild) < 0) {
list.set(maxIndex, current);
list.set(currentIndex, maxChild);
currentIndex = maxIndex;
} else {
break;
}

}

return removedOject;
}

/** Remove the root from the heap */
public E remove2() {
if (list.size() == 0)
return null;

E removedObject = list.get(0);
list.set(0, list.get(list.size() - 1));
list.remove(list.size() - 1);

int currentIndex = 0;
while (currentIndex < list.size()) {
int leftChildIndex = 2 * currentIndex + 1;
int rightChildIndex = 2 * currentIndex + 2;

// Find the maximum between two children
if (leftChildIndex >= list.size())
break; // The tree is a heap
int maxIndex = leftChildIndex;
if (rightChildIndex < list.size()) {
if (list.get(maxIndex).compareTo(list.get(rightChildIndex)) < 0) {
maxIndex = rightChildIndex;
}
}

// Swap if the current node is less than the maximum
if (list.get(currentIndex).compareTo(list.get(maxIndex)) < 0) {
E temp = list.get(maxIndex);
list.set(maxIndex, list.get(currentIndex));
list.set(currentIndex, temp);
currentIndex = maxIndex;
} else
break; // The tree is a heap
}

return removedObject;
}

/*public ArrayList<E> heapSort() {
for (int i = 0; i < list.size(); i++) {
E temp  = list.get(i);
list.set(i, this.remove());
}

return list;
}
*/
/** Get the number of nodes in the tree */
public int getSize() {
return list.size();
}

public static void main(String[] args) {
Integer[] list = { 2, 1, 3, 5, 0, 12, 34, 22, 89, 11 };
Heap<Integer> heap = new Heap<>(list);

for (int i = list.length - 1; i >=0; i--) {
//System.out.print(heap.remove() + " ");
list[i] = heap.remove();
}

for (int i = 0; i < list.length; i++) {
System.out.print(list[i] + " ");
}
}

}