堆排序和桶排序及代码

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


一、堆

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

完全二叉树:树中的结点按从上至下、从左到右的顺序进行编号。对于编号为i的节点,它的左孩子编号为 2 ∗ i + 1 2*i+1 2i+1,右孩子编号为 2 ∗ i + 2 2*i+2 2i+2,父节点编号为 ( i − 1 ) / 2 (i-1)/2 (i1)/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);
	}

总结

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值