堆排序和桶排序及代码

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、堆

堆是完全二叉树，分为大根堆和小根堆。

完全二叉树：树中的结点按从上至下、从左到右的顺序进行编号。对于编号为i的节点，它的左孩子编号为$2\ast i+1$，右孩子编号为$2\ast i+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(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(NlogN)$，额外空间复杂度$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);
	}

---

总结