提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
一、堆
堆是完全二叉树,分为大根堆和小根堆。
完全二叉树:树中的结点按从上至下、从左到右的顺序进行编号。对于编号为i的节点,它的左孩子编号为 2 ∗ i + 1 2*i+1 2∗i+1,右孩子编号为 2 ∗ i + 2 2*i+2 2∗i+2,父节点编号为 ( i − 1 ) / 2 (i-1)/2 (i−1)/2。
大根堆
每颗子树头节点的值都为最大的完全二叉树。
如何构建:每给出一个数,按完全二叉树的顺序放入数中,若此树比父节点数值大,则将该树与父节点交换。这个过程称为heap insert
public static void heapInsert(int[] arr, int index) {
while(arr[index] > arr[(index - 1)/2]) {
swap(arr, index, (index - 1)/2);
index = (index - 1)/2;
}
}
heapify
public static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1; //左孩子的下标
while (left < size) { //下方还有孩子的时候
// 两个孩子中,谁的值更大,把下标给largest
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
// 父和孩子之间,谁的值更大,把下标给largest
largest = arr[largest] > arr[index] ? largest : index;
if (largest == index) {
break;
}
swap(arr, largest, index);
index = largest;
left = index * 2 + 1;
}
}
O ( l o g N ) O(logN) O(logN)级别的调整代价
小根堆
每颗子树的最小值都是头节点值的完全二叉树。
堆排序
public class HeapSort {
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int heapSize = arr.length;
sawp(arr, 0, --heapSize);
while(heapSize > 0) {
heapify(arr, 0, heapSize); //O(logN)
swap(arr, 0, --heapSize); //O(1)
}
}
}
时间复杂度
O
(
N
l
o
g
N
)
O(NlogN)
O(NlogN),额外空间复杂度
O
(
1
)
O(1)
O(1)。
优先级队列结构就是堆结构。
堆排序扩展题目
己知一个几乎有序的数组,几乎有序是指,如果把数组排好顺序的话,每个元素移动的距离可以不超过k,并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。
public class Code04_SortArrayDistanceLessK {
public void sortedArrDistanceLessK(int[] arr, int k) {
PriorityQueue<Integer> heap = new PriorityQueue<>();
int index = 0;
for (; index < Math.min(arr.length, k); index++) {
heap.add(arr[index]);
}
int i = 0;
for (; index < arr.length; i++, index++) {
heap.add(arr[index]);
arr[i] = heap.poll();
}
while (!heap.isEmpty()) {
arr[i++] = heap.poll();
}
}
}
二、比较器
1)比较器的实质就是重载比较运算符
2)比较器可以很好的应用在特殊标准的排序上
3)比较器可以很好的应用在根据特殊标准排序的结构上
三、桶排序
1)计数排序
2)基数排序
计数排序
基数排序
数组里的数往最高位补零,先按个位数字进编号相同的桶(每个桶可看成一个队列),再按桶的编号由小到大出桶,然后按十位数字进编号相同的桶,以此类推。
public class Code02_RadixSort {
// only for no-negative value
public static void radixSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
radixSort(arr, 0, arr.length - 1, maxbits(arr));
}
public static int maxbits(int[] arr) {
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
}
int res = 0;
while (max != 0) {
res++;
max /= 10;
}
return res;
}
// arr[begin..end]排序
public static void radixSort(int[] arr, int begin, int end, int digit) {
final int radix = 10;
int i = 0, j = 0;
// 有多少数准备多少个辅助空间
int[] bucket = new int[end - begin + 1];
for (int d = 1; d <= digit; d++) { // 有多少位就进出多少次
// 10个空间
// count[0] 当前位(d位)是0的数字有多少个
// count[1] 当前位(d位)是(0和1)的数字有多少个
// count[2] 当前位(d位)是(0、1和2)的数字有多少个
// count[i] 当前位(d位)是(0~i)的数字有多少个
int[] count = new int[radix];
for (i = begin; i <= end; i++) {
j = getDigit(arr[i], d);
count[j]++;
}
for (i = 1; i < radix; i++) {
count[i] = count[i] + count[i - 1];
}
for (i = end; i >= begin; i--) {// 从右往左遍历
j = getDigit(arr[i], d);
bucket[count[j] - 1] = arr[i];
count[j]--;
}
for (i = begin, j = 0; i <= end; i++, j++) {
arr[i] = bucket[j];
}
}
}
public static int getDigit(int x, int d) {
return ((x / ((int) Math.pow(10, d - 1))) % 10);
}