【问题】数据结构：堆排序的排序思想？

堆排序的排序思想？

堆排序（Heap Sort）是一种基于堆数据结构的排序算法，其基本思想可以概括如下：

1. 堆的性质：

• 堆是一种特殊的完全二叉树，分为最大堆和最小堆两种形式。
• 最大堆：父节点的值大于或等于任何一个子节点的值。
• 最小堆：父节点的值小于或等于任何一个子节点的值。

2. 堆排序过程：

• 构建堆：将待排序的数组视为一个完全二叉树，并将其调整为堆。这一过程称为堆化（Heapify）。对于最大堆，可以通过从最后一个非叶子节点开始，依次向前进行下沉操作（调整堆结构），使得每个父节点大于等于其子节点。

• 排序：排序时，每次从堆顶（数组的第一个元素）取出最大（或最小）元素，然后将剩余的堆继续调整为最大堆。这个过程重复进行，直到堆中只剩下一个元素。

3. 具体步骤：

• 构建最大堆：从最后一个非叶子节点开始，依次向前进行下沉操作，直到整个数组成为一个最大堆。
• 排序：每次将堆顶元素（最大元素）与堆的最后一个元素交换，然后减小堆的大小，并对堆顶进行一次下沉操作，使得新的堆顶重新满足最大堆的性质。
• 重复上述过程，直到堆中的元素只剩下一个。

4. 时间复杂度：

• 堆排序的时间复杂度为 O(n log n)，其中建堆操作的时间复杂度为 O(n)，每次调整堆的时间复杂度为 O(log n)。堆排序由于使用了完全二叉树的特性，具有较好的性能。

5. 空间复杂度：

• 堆排序是原地排序，空间复杂度为 O(1)，即只需要常数级别的额外空间用于交换操作。

堆排序通过维护堆的性质，利用堆顶元素的特性来实现排序，具有稳定的时间复杂度和原地排序的优势，适用于需要高效排序大量数据的场景。

具体步骤：

1. 假设数组长度为n，初始时数组为A[1…n]。
2. 将数组从后向前转换为最大堆：

• 从最后一个非叶子节点开始（即A[n/2]），向下调整堆。
• 每个节点向下调整时，比较其值与其子节点的值，如果当前节点的值小于其子节点的值，则与较大的子节点交换。
• 重复上述过程，直到堆顶元素满足最大堆的性质。

3. 将堆顶元素（最大值）与数组的最后一个元素交换，然后重新调整堆。
4. 重复上述过程，直到堆的大小减少到1。

时间复杂度：

• 堆排序的时间复杂度为O(n log n)，其中n是数组的长度。

空间复杂度：

• 堆排序是原地排序算法，不需要额外的存储空间，因此空间复杂度为O(1)。

稳定性：

• 堆排序不是稳定的排序算法，因为相同的元素在排序过程中可能会交换位置。

代码：

// 向下调整算法，使以 parent 为根节点的堆满足大根堆性质
void AdjustDown(int* a, int parent, int n)
{
	assert(a);
	int child = parent * 2 + 1;

	// 确保子节点不超过堆的大小
	while (child < n)
	{
		// 找到左右子节点中较大的一个
		if (child + 1 < n && a[child] < a[child + 1])
		{
			++child;
		}

		// 父节点小于较大子节点，交换父子节点位置
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break; // 父节点已经大于等于子节点，退出循环
		}
	}
}

// 堆排序算法
void HeapSort(int* a, int n)
{
	// 升序排序建大根堆，降序排序建小根堆
	for (int i = (n - 1) / 2; i >= 0; i--) // 从最后一个非叶子节点开始向下调整
	{
		AdjustDown(a, i, n); // 向下调整以 i 为根节点的大根堆
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]); // 将堆顶元素（即最大值）与堆末尾元素交换
		AdjustDown(a, 0, end); // 对新的堆顶进行向下调整，使其满足大根堆性质
		--end; // 堆大小减 1，排除已排序好的最大值
	}
}

使用 priority_queue 实现

逆序：

void heapSort(vector<int>& nums) {
    priority_queue<int> maxHeap;

    // 将数组元素插入最大堆中
    for (int num : nums) {
        maxHeap.push(num);
    }

    // 依次取出堆顶元素放入结果数组中（逆序）
    for (int i = nums.size() - 1; i >= 0; --i) {
        nums[i] = maxHeap.top();
        maxHeap.pop();
    }
}

顺序：

void heapSort(vector<int>& nums) {
    priority_queue<int, vector<int>, greater<int>> minHeap;

    // 将数组元素插入最小堆中
    for (int num : nums) {
        minHeap.push(num);
    }

    // 依次取出堆顶元素放入结果数组中（顺序）
    for (int i = 0; i < nums.size(); ++i) {
        nums[i] = minHeap.top();
        minHeap.pop();
    }
}