堆排序的实现

首先需要知道的是,如果想要对一个数组排升序,要建大堆,排降序,要建小堆。

具体过程:(以排降序为例)

1)建小堆;

2)交换堆顶(第一个)和堆尾(最后一个)的数据;

3)交换完后,最后一个数据不动,剩下的数据对堆顶元素进行向下调整;

4)循环2)3)步骤。

下面用图来展示一下过程:

1)假设对数组arr[10] = {3,1,5,23,64,7,45,37,9,23}进行排序,建好的小堆如图:

dec52651be4d451aa46499df46e727c1.png

2)交换堆顶和堆尾的数据,

66efa9e8e1f8421eab9a42746bc1770a.png

3)对64进行向下调整,进行向下调整时,不将堆尾的1算入数组,那么就是对下图进行调整:

7da5935cac474919b477182a99f10016.png

因为只换了堆顶和堆尾,堆顶的左右子树仍然是小堆,所以可以直接对堆顶调整:

ef3a88bbd7c243759ed97e677249d8a7.png

这里的黄色框内表示没有参与调整。

继续交换:

8f39514ff7574491b9ed06fbd0960495.png

交换完继续对堆顶调整,调整时对下图框外数据调整:

dbcef34a0dbb4e809db0e63d7449e45d.png

以此循环进行,最终实现排序。

部分流程图如下:

fbf218245b684e8699919d638674342c.png

最终得到:

7412b508984648498df2bbc039e031ae.png

以数组形式来看就是{64,45,37,23,23,9,7,5,3,1};实现了降序。

参考代码如下:

void AdjustDown(int* a, int k, int parent)
{
	int child = 2 * parent + 1;

	while (child < k)
	{
		//找左右孩子小的那一个
		if (child + 1 < k && a[child + 1] < a[child])
			child++;
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
int main()
{
    int arr[10] = {3,1,5,23,64,7,45,37,9,23};
    int k = sizeof(arr)/sizeof(arr[0]);
    int i = 0;
    for (i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr,k,i);
	}
	int end = n - 1;
	while(end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDwon(a, end, 0);
		end--;
	}
}

 

 

 

  • 7
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 好的,以下是Java语言实现堆排序的代码: ```java public class HeapSort { public void sort(int[] arr) { int n = arr.length; // 建堆(将数组变为最大堆) for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // 一个一个从堆顶取出元素,放到数组末尾 for (int i = n - 1; i > 0; i--) { int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // 重新建堆 heapify(arr, i, 0); } } // 调整堆 void heapify(int[] arr, int n, int i) { int largest = i; // 假设当前节点最大 int l = 2 * i + 1; // 左子节点 int r = 2 * i + 2; // 右子节点 // 如果左子节点比当前节点大,更新最大值 if (l < n && arr[l] > arr[largest]) largest = l; // 如果右子节点比当前节点大,更新最大值 if (r < n && arr[r] > arr[largest]) largest = r; // 如果最大值不是当前节点,交换它们,并递归调整下一层的堆 if (largest != i) { int swap = arr[i]; arr[i] = arr[largest]; arr[largest] = swap; heapify(arr, n, largest); } } } ``` 这段代码实现堆排序算法,其时间复杂度为 O(nlogn)。 ### 回答2: 堆排序是一种利用完全二叉树结构的排序算法,其中完全二叉树的每个节点的值都大于等于(或小于等于)其子节点的值。Java中的堆排序实现代码如下: ```java public class HeapSort { public void sort(int[] arr) { int n = arr.length; // 构建最大堆(使arr[i]成为根节点) for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // 逐个将最大值(根节点)移到数组末尾 for (int i = n - 1; i >= 0; i--) { // 将当前根节点(最大值)与数组末尾交换 int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // 重新构建最大堆 heapify(arr, i, 0); } } void heapify(int[] arr, int n, int i) { int largest = i; // 初始化根节点为最大值 int l = 2 * i + 1; // 左子节点 int r = 2 * i + 2; // 右子节点 // 如果左子节点较大,则更新根节点 if (l < n && arr[l] > arr[largest]) largest = l; // 如果右子节点较大,则更新根节点 if (r < n && arr[r] > arr[largest]) largest = r; // 如果根节点不是最大值,则交换根节点与最大值的位置,并继续向下构建最大堆 if (largest != i) { int swap = arr[i]; arr[i] = arr[largest]; arr[largest] = swap; heapify(arr, n, largest); } } } ``` 这段代码实现堆排序算法。首先,构建一个最大堆,在每次构建堆的过程中将当前根节点(最大值)与数组末尾交换,然后减小堆的大小再重新构建最大堆。通过不断重复这个过程,直到整个数组有序。堆排序算法的时间复杂度为O(nlogn),在最坏和平均情况下都是如此。 ### 回答3: 堆排序是一种基于完全二叉树的排序算法,它的实现主要涉及到建立堆和调整堆的操作。 下面是Java的堆排序实现代码: ```java public class HeapSort { public static void heapSort(int[] arr) { int n = arr.length; // 构建堆 for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // 从堆中提取元素并调整堆 for (int i = n - 1; i > 0; i--) { int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; heapify(arr, i, 0); } } // 调整堆 public static void heapify(int[] arr, int n, int i) { int largest = i; // 将当前节点设为最大值 int left = 2 * i + 1; // 左子节点 int right = 2 * i + 2; // 右子节点 // 若左子节点大于当前节点,将左子节点设为最大值 if (left < n && arr[left] > arr[largest]) largest = left; // 若右子节点大于当前节点,将右子节点设为最大值 if (right < n && arr[right] > arr[largest]) largest = right; // 若最大值不是当前节点,交换当前节点与最大值,并递归调整堆 if (largest != i) { int swap = arr[i]; arr[i] = arr[largest]; arr[largest] = swap; heapify(arr, n, largest); } } // 测试 public static void main(String[] args) { int[] arr = {10, 7, 8, 9, 1, 5}; heapSort(arr); System.out.println("排序后的数组:"); for (int ele : arr) { System.out.print(ele + " "); } } } ``` 以上代码中,`heapSort`函数用于实现堆排序,`heapify`函数用于调整堆。首先通过`heapify`函数构建最大堆,然后从堆中提取元素并调整堆,直到堆为空。在`main`函数中,我们定义一个数组并调用`heapSort`函数进行排序,然后打印排序后的数组。 堆排序是一种高效的排序算法,时间复杂度为O(nlogn),它的实现非常灵活,可以用于对各种类型的数据进行排序。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值