
本文共 3635 字,大约阅读时间需要 12 分钟。
���������
������������������������������
���������������������������������������������������������������������������������������������������������������heap������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
������������������
���������������������������������������������������������������������������������������������������������������������������������������������
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
���������������������������������������������������������������������������������������������������������
���������������������������������������O(n log n)���������������������������������������������������
������������������
������������������������������������������������������������������������������������������������������������������������
���������������������������������������������������������������������������������������������������������parent���child���������������������������������������������������������������
���������������������������������������������������������������������������������������������������������������������������������
������������������������������������������
public class HeapSort { public static void sort(int[] data) { int len = data.length; for (int i = 0; i < len; i++) { buildMaxHeap(data, len - 1 - i); } return data; } private static void buildMaxHeap(int[] data, int lastindex) { int k = (lastindex - 1) / 2; while (k >= 0) { int biggerIndex = 2 * k + 1; if (biggerIndex > lastindex) { break; } if (data[biggerIndex] > data[k]) { swap(data, k, biggerIndex); } k--; } } private static void swap(int[] data, int i, int j) { int temp = data[i]; data[i] = data[j]; data[j] = temp; }}
���������������������������������������
buildMaxHeap
������������������������������������������������������������������������������������������������������������swap
���������������������������������������������������������������������������������������������
���������������������������������������������������������������������������������
������������������������
������������������������������������������������������������������������������������������������������������������������������������������������
������������������������������������������������O(n log n)���������������������������������������������������������������������������������������������
������������������������������������������������O(1)���������������������������������������������������������������
������������������ilities������������������������������������������������������������������Keys���������������������������������������������������������������������
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
发表评论
最新留言
关于作者
