java 堆排序

本文详细介绍了堆排序算法的实现过程,包括如何构建初始的小根堆、调整堆的过程以及完整的堆排序流程。通过具体代码示例展示了堆排序的时间复杂度为O(nlogn),并给出了一个完整的Java实现案例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

复杂度最坏: nlgn  代码中有标注

和top n 问题关系:用的堆模型,和top n 问题用的模型相同

http://blog.youkuaiyun.com/nx188/article/details/51218846

createHeap    从1开始遍历堆去令每个节点做child, 用child 去找parent, 

adjustHeap    parent 一直是0, 用parent 去和lChild 和rChild 去比较, 这个是log N,  每个节点都置换一次最小值, 就是O(n), 所以是nlogN

代码:

package AlgorithmTopK;

public class Heapsort {
	
	//建立小根堆  super.createHeap(int input[], int K);
	public int[] createHeap(int input[]) {  //创建小根堆
		int heap[] = new int[input.length];
		for(int i=0;i<input.length;i++)
			heap[i] = input[i];
		for(int i = 1;i < heap.length;i++) {   //这个复杂度是 n
			int child = i;
			int parent = (child-1) / 2;
			while(parent >= 0 && child!=0 && heap[parent] > heap[child]) {  //这个复杂度最坏是lgn
				int temp = heap[child];
				heap[child] = heap[parent];
				heap[parent] = temp;
				child = parent;
				parent = (parent - 1) / 2;
			}
		}
		return heap;
	}
	
	//循环根和最后一个换,再调整堆   根和倒数第二个换,再调整堆  直到根和左儿子交换后,不用再调整堆
	public void adjustHeap(int[] heap, int last) {
		//先把根和heap[last]交换,
		int temp = heap[0];
		heap[0] = heap[last];
		heap[last] = temp;	
		//再调整堆
		if(last > 1) {
			int parent = 0;
			while(parent < last-1) {   //这个循环复杂度最坏是  lgn
				int lchild = parent*2 + 1;
				int rchild = parent*2 + 2;
				int minIndex = parent;  //指向左右儿子中最小的
				if(lchild < last-1 && heap[lchild] < heap[parent])
					minIndex = lchild;
				if(rchild < last-1 && heap[rchild] < heap[minIndex])
					minIndex = rchild;
				if(minIndex == parent) {
					break;
				}
				else {
					temp = heap[minIndex];
					heap[minIndex] = heap[parent];
					heap[parent] = temp;
					parent = minIndex;
				}
			}
		} 
	}
	
	//打印结果数组
	public int[] heapSort(int[] input) {
		int[] smallRootHeap = createHeap(input);   //复杂度最坏是nlgn
		for(int i=smallRootHeap.length-1;i>0;i--)  //复杂度最坏是nlgn
			adjustHeap(smallRootHeap, i);
		return smallRootHeap;
	}
			
	public static void main(String[] args) {
		int a[] = {5,4,1,2,6,7,9,10,2,3};
		int result[] = new Heapsort().heapSort(a);
		for(int resultItem : result) {
			System.out.print(resultItem + " ");
		}
	}

}
结果:

10 9 7 6 5 4 3 2 2 1 






### Java堆排序的实现与原理 #### 1. 堆排序的基本原理 堆排序是一种基于比较的排序算法,主要依赖于一种称为“堆”的特殊数据结构。堆可以分为两种形式:**大顶堆**和**小顶堆**。 - **大顶堆**是指父节点的值总是大于等于子节点的值。 - **小顶堆**则是指父节点的值总是小于等于子节点的值。 堆排序的核心思想是先将待排序的数据构建为一个大顶堆(或小顶堆)。对于升序排序来说,通常采用大顶堆;而对于降序排序,则使用小顶堆。随后不断取出堆顶元素(即当前最大值或最小值),并将剩余部分重新调整成一个新的堆,直到所有元素都被处理完毕[^3]。 #### 2. 构建堆的过程 为了完成堆排序,需要解决两个核心问题: 1. 将无序数组转换为一个合法的大顶堆。 2. 在每次移除堆顶元素后,能够动态维护剩下的部分仍满足堆的定义。 ##### (a) 调整堆的操作 假设已经有一个接近堆结构的部分数组,可以通过自底向上的方式逐步修复堆属性。具体做法是从某个非叶子节点开始向下遍历,如果发现该节点不符合堆的要求(比如在大顶堆中,父节点小于子节点),则交换父子节点的位置,并继续递归地检查被交换后的子节点是否仍然违反堆规则[^4]。 以下是调整堆的一个伪代码表示: ```java private void heapify(int[] array, int length, int i) { int largest = i; // 初始化最大值索引为根节点 int leftChild = 2 * i + 1; int rightChild = 2 * i + 2; // 如果左孩子存在且大于当前最大值 if (leftChild < length && array[leftChild] > array[largest]) { largest = leftChild; } // 如果右孩子存在且大于当前最大值 if (rightChild < length && array[rightChild] > array[largest]) { largest = rightChild; } // 如果最大值不是根节点,交换它们并递归调用heapify if (largest != i) { swap(array, i, largest); heapify(array, length, largest); // 继续下沉 } } ``` ##### (b) 初始堆化过程 初始阶段,我们需要把整个输入数组转化为一个完整的堆。由于完全二叉树的特点决定了最后一个非叶节点位于 `(n/2)-1` 的位置,所以可以从这个位置向前依次对每一个内部节点执行 `heapify` 操作[^1]。 #### 3. 完整的堆排序流程 一旦完成了初始化堆的工作之后,就可以按照如下步骤来进行最终的排序: 1. 取出堆顶元素放到已排序区域的最后一项; 2. 缩短未排序区间的长度; 3. 对新的未排序区间再次进行 `heapify` 处理以恢复堆特性; 4. 循环上述三步直至全部元素都进入到了已排序状态之中。 下面是完整的 Java 实现代码: ```java public class HeapSort { public static void sort(int[] array) { int n = array.length; // Build max heap. for (int i = n / 2 - 1; i >= 0; i--) { heapify(array, n, i); } // Extract elements one by one from the heap and place them at their correct positions. for (int i = n - 1; i > 0; i--) { // Move current root to end of unsorted part. swap(array, 0, i); // Call max heapify on reduced heap. heapify(array, i, 0); } } private static void heapify(int[] array, int length, int i) { int largest = i; // Initialize largest as root int leftChild = 2 * i + 1; int rightChild = 2 * i + 2; // If left child is larger than root if (leftChild < length && array[leftChild] > array[largest]) { largest = leftChild; } // If right child is larger than largest so far if (rightChild < length && array[rightChild] > array[largest]) { largest = rightChild; } // If largest is not root if (largest != i) { swap(array, i, largest); heapify(array, length, largest); // Recursively heapify affected sub-tree } } private static void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } public static void main(String[] args) { int[] data = {4, 10, 3, 5, 1}; System.out.println("Original Array:"); printArray(data); sort(data); System.out.println("\nSorted Array:"); printArray(data); } private static void printArray(int[] array) { for (int value : array) { System.out.print(value + " "); } } } ``` 这段程序展示了如何通过堆排序技术有效地对一组随机数列实施升序排列[^2]。 --- ### 总结 堆排序以其时间复杂度 $O(n \log n)$ 和原地工作的特点,在很多场合下表现出色。虽然它不像快速排序那样平均表现更佳,但它具有最坏情况下的线性对数级效率优势[^5]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值