数据结构_ 堆结构与堆排序(c++ 实现 + 完整代码 )

最新推荐文章于 2024-03-11 13:14:16 发布
最新推荐文章于 2024-03-11 13:14:16 发布
阅读量923 收藏 2
点赞数 2
分类专栏： 数据结构与算法 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jj6666djdbbd/article/details/129168604
版权

堆结构与堆排序

文章目录

引入堆

  • 二叉树
    具有左孩子与右孩子的最普通的二叉树。

  • 满二叉树
    特殊的二叉树：每个节点如果有孩子则一定同时具有左孩子与右孩子。

满二叉树的条件：

  1. 要么有两个孩子，要么没有孩子
  2. 叶子节点在同一层

满二叉树有如下规律：
​如果层数为n
第n层节点数 一定为 2^(n-1)
整颗树节点数 为 2^n - 1

  • 完全二叉树
    能够使得满二叉树 从 下边和右边开始删节点的 二叉树 , 满足从右往左 从下往上删除 （和 阅读顺序 相反）

    1. 满二叉树一定是完全二叉树

    2. 完全二叉树不一定是满二叉树

  • 堆

    ​ 堆是有序的完全二叉树。

    ​ 父子之间必须有序，父大于子或者子大于父，同层兄弟之间不用管

    1. 父大于子：最大堆（大顶堆）
    2. 子大于父：最小堆（小顶堆）

堆结构所满足的数学特性

在这里插入图片描述

下标关系：

  • 150 的 下标为 0 ，260 的下标为1，290的下标为3，400的下标为7。共同点：都是父节点的左孩子，父节点的下标*2+1=左孩子的下标

  • 150的下标为0，300的下标为2，400的下标为6；260的下标为1，320的下标为4，500的下标为10。共同点：都是父节点的右孩子，父节点的下标*2+2=右孩子的下标

  • 相反，已知400的下标为7，则290的下标为3，260的下标为1。共同点：已知左孩子的下标，（左孩子下标-1）/2得到父节点的下标

  • 已知500的下标为10，320的下标为4，260 的下标为1。共同点：已知右孩子的下标，（右孩子下标-2）/2得到父节点的下标

    总结：

    父亲推孩子：

    已知父节点下标为N
    左孩子下标为：2*N + 1

    右孩子下标为：2*N + 2

    孩子反推父亲：

    已知左孩子下标为M 父节点下标为： (M-1)/2
    已知右孩子下标为M 父节点下标为： (M-2)/2

    已知孩子下标为M 父节点下标为： (M-1)/2

准备代码

template <class T>
class My_Heap
{
private:
	T* pRoot;	//指向堆的指针，实际上是一个动态数组
	int len;	//元素个数
	int MaxLen;	//容量
public:
	My_Heap()
	{
		pRoot = nullptr;
		len = MaxLen = 0;
	}
	~My_Heap()
	{
		delete[] pRoot;
		pRoot = nullptr;
		len = MaxLen = 0;
	}

	//往堆中插入元素
	void insert(const T& data);
	//遍历
	void travel()const;
	//删除堆顶
	T pop();
};

----------- 往堆中插入元素

我们采用 小顶堆的方式，即保证孩子节点要比父亲节点大。
采用动态内存分配的方法，插入一个节点到数组中。
从堆底开始，根据下标关系找到对应的父节点.

插入步骤：（小顶堆）

  1. 比较插入节点与当前父节点的关系
  2. 如果比父节点小，则当前节点需要上提，交换当前节点与父节点的值
  3. 如果比父节点大，则说明不冲突，则直接退出即可，因为经过以前的处理此情况一定是合法的。
  4. 继续比较，直到不冲突或者到达了根节点为止。

注意：我们使用自底向上的方式，每次比较当前节点与父节点的关系，然后需要将当前节点往上提，继续比较和上一层的关系

图例：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

要点：从下往上遍历，交换不合适的节点。

template<class T>
inline void My_Heap<T>::insert(const T& data)
{
	//动态数组
	//1 像动态数组一样进来
	if (MaxLen <= len) {//需要申请
		//计算需要申请的内存大小   //>>1 右移一位 等同于除以2
		MaxLen = MaxLen + (((MaxLen >> 1) > 1) ? (MaxLen >> 1) : 1);
		//1 开内存
		T* pNew = new T[MaxLen];
		if (pRoot) {
			//2 pArr指向内存段中数据拷贝到pNew指向内存段
			memcpy(pNew, pRoot, sizeof(T) * len);
			//3 释放pArr指向内存段
			delete[] pRoot;
		}
		//4 pArr指向新开内存
		pRoot = pNew;
	}
	pRoot[len++] = data;

	//循环和父节点比较，如果冲突交换，不冲突，覆盖
	if (len == 1)
	{
		return;
	}
	int CurrentIdx= len - 1;				//孩子节点
	int ParentIdx = (CurrentIdx - 1) / 2;	//父节点
	T temp;
	while (1)
	{
		if (CurrentIdx <= 0)
			break;		//没有父节点，循环结束
		ParentIdx = (CurrentIdx - 1) / 2;
		if (pRoot[ParentIdx] < pRoot[CurrentIdx])
			break;	//不冲突，孩子父亲大，则停止
		//否则，交换元素
		temp = pRoot[ParentIdx];
		pRoot[ParentIdx] = pRoot[CurrentIdx];
		pRoot[CurrentIdx] = temp;
		//遍历完一次后，接着往上移动，开始重新一次比较
		CurrentIdx = ParentIdx;
	}
}

不使用动态内存分配：

void InsertData(int val)
	{
		arr[++this->size] = val;
		if (this->size == 1) return;
		int curLen = this->size;//当前节点
		int parentLen = curLen >> 1;//父节点
		while (true)
		{
			if (curLen <= 1) break;//到达根节点，退出
			//比较和父节点的关系，比父节点小则交换
			parentLen = curLen >> 1;
			if (arr[curLen] > arr[parentLen])
			{
				break;
			}
			swap(arr[curLen], arr[parentLen]);
			curLen = parentLen;
		}
	}

----------- 删除堆顶

从堆顶开始，把最后一个元素覆盖堆顶元素，接着根据下标关系，找到堆顶的孩子节点，比较两个孩子谁是最小孩子，如果堆顶比最小孩子节点小，则退出（小顶堆）。否则，交换两个节点，要保证父小于子。然后顶堆往下移动，移动到下一层的父节点，比较父子关系。确保在覆盖了原堆顶（即删除了原堆顶）后，整个堆结构仍然是以小堆顶的结构，因此要进行重排，直到数组下标越界为止。

步骤：

  1. 最后一个元素覆盖堆顶元素
  2. 当前节点寻找两个孩子节点的最小的那个，并且把那个最小的与当前节点的值作交换
  3. 当前节点下移，继续寻找最小的元素并且作交换
  4. 直到超过了下界之后停止。

注意：如果堆顶元素比左右孩子最小的元素都小，则不冲突，因此直接结束循环

图例：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

要点：从上往下遍历，重排堆结构的父子关系。

template <class T>
//删除堆顶
T MyHeap<T>::pop(){
	if (0 == len){
		cout << "堆为空，删除失败!" << endl;
		return (T)0;
	}//没法删
	if (1 == len){//只有一个
		len--;
		return pRoot[0];
	}
	//1 临时保存堆顶元素
	T temp = pRoot[0];
	//2 最后一个覆盖堆顶元素
	pRoot[0] = pRoot[len - 1];
	//3 循环  
	int currentIdx = 0;//从堆顶开始
	int minChildIdx;
	while (1){
		//数组结束 
		if ((currentIdx * 2 + 1) > (len - 1) ||
			(currentIdx * 2 + 2) > (len - 1)){
			break;
		}
		// 找到最小的孩子 
		minChildIdx = currentIdx * 2 + 1;//假定左孩子比较小
		//如果左孩子比右孩子大，右孩子最小
		if (pRoot[minChildIdx] > pRoot[minChildIdx + 1]) 
			minChildIdx++;
		//比最小孩子还小 循环结束
		if (pRoot[len-1] < pRoot[minChildIdx]) break;
		//当前位置和最小孩子交换 //子覆盖父
        //简单交换方式
        temp1 = pRoot[CurrentIdx];
		pRoot[CurrentIdx] = pRoot[MinChildIdx];
		pRoot[MinChildIdx] = temp1;
		//往下移动
		currentIdx = minChildIdx;
	}

	//4 返回
	len--;
	return temp;
}

不使用动态内存分配

int pop()
	{
		/*
		删除堆顶元素
		*/
		if (this->size == 1)
		{
			this->size = 0;
			return arr[1];
		}
		//1. 最后一个元素覆盖堆顶元素
		int temp = arr[1];
		arr[1] = arr[this->size];
		int curLen = 1;//当前节点
		int childLen = curLen << 1;//孩子节点
		while (true)
		{
			//下移超过了边界则退出
			if (((curLen << 1) > this->size) || (curLen << 1 | 1) > this->size)
			{
				break;
			}
			//找到两个孩子中最小的一个
			childLen = curLen << 1;//默认最小的是左孩子
			if (arr[childLen] > arr[childLen + 1])
			{
				childLen += 1;//最小的为右孩子
			}
			//堆顶比最小的孩子还小，则无需交换
			if (arr[this->size] < arr[childLen]) break;
			//交换当前节点与孩子节点的值
			swap(arr[childLen], arr[curLen]);
			curLen = childLen;//下移到孩子
		}
		this->size--;//最后总的个数要减一个
		return temp;
	}

堆排序构建

template <class T>
//直接用数组方式来构建堆
void MyHeap<T>::initHeap(T* pArr, int size){
	//开内存
	maxLen = size;
	len = 0;
	pRoot = new T[size];
	//数据进来
	pRoot[len++] = pArr[0];//第一个
	int currentIdx;
	int parentIdx;
	for (int i = 1; i < size; i++){
		currentIdx = len;
		parentIdx = (currentIdx - 1) / 2;


		//数据先放进来
		pRoot[currentIdx] = pArr[i];

		while (1){
			if (currentIdx <= 0) break;//没有父节点 循环结束
			parentIdx = (currentIdx - 1) / 2;
			if (pRoot[parentIdx] < pRoot[currentIdx]) break;

			//冲突 父节点覆盖子节点
			pRoot[currentIdx] = pRoot[parentIdx];
			//往上移
			currentIdx = parentIdx;
		}
		//新数据覆盖回来
		pRoot[currentIdx] = pArr[i];
		//个数增加
		len++;
	}
}

完整代码及测试

动态分配版本

在这里插入图片描述

#pragma once
#include <iostream>
using namespace std;
template <class T>
class My_Heap
{
private:
	T* pRoot;	//指向堆的指针，实际上是一个动态数组
	int len;	//元素个数
	int MaxLen;	//容量
public:
	My_Heap()
	{
		pRoot = nullptr;
		len = MaxLen = 0;
	}
	~My_Heap()
	{
		delete[] pRoot;
		pRoot = nullptr;
		len = MaxLen = 0;
	}

	//往堆中插入元素
	void insert(const T& data);
	//遍历
	void travel()const;
	//删除堆顶
	T pop();
	void initHeap(T* pArr, int size);
};

template<class T>
inline void My_Heap<T>::insert(const T& data)
{
	//动态数组
	//1 像动态数组一样进来
	if (MaxLen <= len) {//需要申请
		//计算需要申请的内存大小   //>>1 右移一位 等同于除以2
		MaxLen = MaxLen + (((MaxLen >> 1) > 1) ? (MaxLen >> 1) : 1);
		//1 开内存
		T* pNew = new T[MaxLen];
		if (pRoot) {
			//2 pArr指向内存段中数据拷贝到pNew指向内存段
			memcpy(pNew, pRoot, sizeof(T) * len);
			//3 释放pArr指向内存段
			delete[] pRoot;
		}
		//4 pArr指向新开内存
		pRoot = pNew;
	}
	pRoot[len++] = data;

	//循环和父节点比较，如果冲突交换，不冲突，覆盖
	if (len == 1)
	{
		return;
	}
	int CurrentIdx= len - 1;				//孩子节点
	int ParentIdx = (CurrentIdx - 1) / 2;	//父节点
	T temp;
	while (1)
	{
		if (CurrentIdx <= 0)
			break;		//没有父节点，循环结束
		ParentIdx = (CurrentIdx - 1) / 2;
		if (pRoot[ParentIdx] < pRoot[CurrentIdx])
			break;	//不冲突，循环继续
		//效率较低
		temp = pRoot[ParentIdx];
		pRoot[ParentIdx] = pRoot[CurrentIdx];
		pRoot[CurrentIdx] = temp;
		//往上移动
		CurrentIdx = ParentIdx;
	}
}

template<class T>
inline void My_Heap<T>::travel() const
{
	for (int i = 0; i < len; i++)
	{
		cout << pRoot[i] << " ";
	}
	cout << endl;
}

template<class T>
inline T My_Heap<T>::pop()
{
	if (len == 0)
	{
		cout << "堆为空!\n";
		return (T)0;
	}
	if (len == 1)
	{
		len--;	//只有一个元素
		return pRoot[0];
	}

	//1. 临时保存堆顶元素
	T temp = pRoot[0];
	T temp1;
	//2. 最后一个元素覆盖堆顶元素
	pRoot[0] = pRoot[len - 1];

	//从堆顶开始
	int CurrentIdx = 0;
	int MinChildIdx;
	while (1)
	{
		//越界
		if ((CurrentIdx * 2 + 1) > (len - 1) ||
			(CurrentIdx * 2 + 2) > (len - 1))
		{
			break;
		}
		//找到最小孩子
		//先假设左孩子比较小
		MinChildIdx = CurrentIdx * 2 + 1;
		if (pRoot[MinChildIdx] > pRoot[MinChildIdx + 1])
		{
			MinChildIdx++;	//右孩子比较小
		}
		//如果比最小孩子还小
		if (pRoot[len-1] < pRoot[MinChildIdx])
			break;
		//需要交换，采用简单交换, 子覆盖父
		temp1 = pRoot[CurrentIdx];
		pRoot[CurrentIdx] = pRoot[MinChildIdx];
		pRoot[MinChildIdx] = temp1;
		//父节点往下移动
		CurrentIdx = MinChildIdx;
	}

	len--;
	return temp;
}

template <class T>
//直接用数组方式来构建堆
void My_Heap<T>::initHeap(T* pArr, int size) {
	//开内存
	MaxLen = size;
	len = 0;
	pRoot = new T[size];
	//数据进来
	pRoot[len++] = pArr[0];//第一个
	int currentIdx;
	int parentIdx;
	for (int i = 1; i < size; i++) {
		currentIdx = len;
		parentIdx = (currentIdx - 1) / 2;


		//数据先放进来
		pRoot[currentIdx] = pArr[i];

		while (1) {
			if (currentIdx <= 0) break;//没有父节点 循环结束
			parentIdx = (currentIdx - 1) / 2;
			if (pRoot[parentIdx] < pRoot[currentIdx]) break;

			//冲突 父节点覆盖子节点
			pRoot[currentIdx] = pRoot[parentIdx];
			//往上移
			currentIdx = parentIdx;
		}
		//新数据覆盖回来
		pRoot[currentIdx] = pArr[i];
		//个数增加
		len++;
	}
}

#include "MyHeap.h"

#define NUM 11
int main()
{
	int arr[NUM] = { 150,260,300,290,320,350,500,400,450,490,500 };
	My_Heap<int> a;

	/*for (int i = 0; i < NUM; i++)
	{
		a.insert(arr[i]);
		a.travel();
	}*/
	a.initHeap(arr, NUM);
	a.travel();
	return 0;
}

非动态版本

P1177 【模板】快速排序 ----排序测试

Ac code

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
using namespace std;
#define int long long
const int N = 1e5 + 10;
const int CurSize = 1e5 + 10;
struct Tree
{
	int arr[N];
	int size;
	Tree() { memset(arr, 0, sizeof(arr)); size = 0; }
	void InsertData(int val)
	{
		arr[++this->size] = val;
		if (this->size == 1) return;
		int curLen = this->size;//当前节点
		int parentLen = curLen >> 1;//父节点
		while (true)
		{
			if (curLen <= 1) break;//到达根节点，退出
			//比较和父节点的关系，比父节点小则交换
			parentLen = curLen >> 1;
			if (arr[curLen] > arr[parentLen])
			{
				break;
			}
			swap(arr[curLen], arr[parentLen]);
			curLen = parentLen;
		}
	}
	int pop()
	{
		/*
		删除堆顶元素
		*/
		if (this->size == 1)
		{
			this->size = 0;
			return arr[1];
		}
		//1. 最后一个元素覆盖堆顶元素
		int temp = arr[1];
		arr[1] = arr[this->size];
		int curLen = 1;//当前节点
		int childLen = curLen << 1;//孩子节点
		while (true)
		{
			//下移超过了边界则退出
			if (((curLen << 1) > this->size) || (curLen << 1 | 1) > this->size)
			{
				break;
			}
			//找到两个孩子中最小的一个
			childLen = curLen << 1;//默认最小的是左孩子
			if (arr[childLen] > arr[childLen + 1])
			{
				childLen += 1;//最小的为右孩子
			}
			//堆顶比最小的孩子还小，则无需交换
			if (arr[this->size] < arr[childLen]) break;
			//交换当前节点与孩子节点的值
			swap(arr[childLen], arr[curLen]);
			curLen = childLen;//下移到孩子
		}
		this->size--;//最后总的个数要减一个
		return temp;
	}
};
signed main()
{
	Tree t;
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		int p;
		cin >> p;
		t.InsertData(p);
	}
	while (t.size != 0)
	{
		cout << t.pop() << " ";
	}
	return 0;
}
Yuleo_
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++ 数据结构 堆排序的实现
01-20
堆排序（heapsort）是一种比较快速的排序方式，它的时间复杂度为O(nlgn)，并且堆排序具有空间原址性，任何时候只需要有限的空间来存储临时数据。我将用c++实现一个堆来简单分析一下。 堆排序的基本思想为： 1、升序...
C++实现堆排序
08-25
1、 实现堆排序算法。 2、 理论分析并实验验证堆排序算法的时间复杂度。
堆排序——C语言实现
热门推荐
qq_41890240的博客
03-08 1万+
在实现堆排序之前，我们先讲解一些必备的知识点。 一、什么是堆？ 堆的逻辑结构是完全二叉树； 堆的物理结构是一个数组。 二、堆的分类： 大堆：所有的父亲大于等于孩子； 小堆：所有的父亲小于等于孩子。 三、父亲和孩子的下标关系： leftchild=parent×2+1; rightchild=parent×2+2; parent=(child-1)/2。 四、堆能干什么？ 大堆能保证堆顶的数最大； 小堆能保证堆顶的数最小； 堆排序也正是利用这一特性进行排序的。
堆排序及代码详解
Currybeefer的博客
04-20 3199
堆排序（英语:Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的时间复杂度为nlogn，堆排序是一种不稳定的排序算法。 以下是堆排序的代码，思路都在注释里了，记得从下往上看。 如果还没有搞懂，点击这里进行参考 /// 大顶堆调整方法 void MaxHeapify(int arr[],int start, int end) { //start代表需要调整的节点 //end
经典排序算法之堆排序详解|c++代码实现|什么是堆排序|如何代码实现堆排序
最新发布
qq_64431512的博客
03-11 945
经典排序算法之堆排序详解|c++代码实现|什么是堆排序|如何代码实现堆排序
C++堆排序（完整版）
code进击者
02-28 3750
堆排序步骤： （1）变为大顶堆；根节点的值大于等于其孩子节点的值。堆是一个完全二叉树，很适合用顺序结构来实现，这里我们选择数组。 （2）最后一个数据和最顶部节点数据交换（最大值放在最后），然后再进行一次调整（heapify函数），变为大顶堆（此时heapsize减1）。 #include &lt;iostream&gt; #include &lt;vector&gt; using name...
C++实现排序算法之堆排序
qq_38307826的博客
07-17 3561
一、算法思想 堆排序是利用堆性质进行的一种选择排序 概念： 堆：堆是一棵顺序存储的完全二叉树 每个节点的值都不大于其左右孩子节点的值的堆叫做小根堆（下左图） 每个节点的值都不小于其左右孩子节点的值的堆叫做大根堆（下右图） 设当前元素在数组中以R[i]表示，那么， (1) 它的左孩子结点是：R[2*i+1]; (2) 它的右孩子结点是：R[2*i+2]; (3) 它的父结点是：R[(i-1)/2]; (4) R[i] <= R[2*i+1] 且 R[i] <= R[2i+2]。 堆排序步骤如下：
排序算法之堆排序的实现
05-15 1590
用于记录数据结构和算法的学习过程
数据结构C++代码（排序）
11-10
数据结构C++代码（排序）包含：冒泡排序、选择排序、插排、快速排序、堆排序、桶排序、希尔排序、归并排序
C++实现数据结构排序代码
11-10
用VS编写的C++排序算法，包括冒泡、插入、堆排序、选择排序、快速排序、希尔排序等各种排序方法
解读堆排序算法及用C++实现基于最大堆的堆排序示例
12-25
1、堆排序定义 n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)： (1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ ) 若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的...
堆排序详解与代码实现
IronmanJay的博客
01-17 788
文章目录一、堆排序基本介绍二、大顶堆和小顶堆2.1 大顶堆2.2 小顶堆三、堆排序基本思想四、堆排序代码实现五、代码运行结果 一、堆排序基本介绍 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，他的最好、最坏、平均时间复杂度均为O(nlogn)，它也是不稳定排序 堆是具有以下性质的二叉树：每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆。注意：没有要求节点的左孩子和右孩子的值的大小关系 每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆 一般升序采用大顶堆，降序采用小顶堆
堆排序代码详解
公众号：风景邮递Yuan的博客
07-03 961
• 堆是一个完全二叉树；• 堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的 值。 左侧为大顶堆 右侧为小顶堆
java代码实现堆排序（注释超详细）
Ysong666的博客
02-28 2659
这是我的最新修改：之前的代码有点小bug，一直没有解决，就找了一个新的代码。 public static void heapSort(int[] tree,int n) { buildHeap(tree, n);//第一步是将得到的数组构建成大顶堆 for(int i = n-1;i>=0;i--) { swap(tree, i, 0);//第一次构建完大顶堆之后...
堆排序的c++代码实现
Riley_chen的博客
10-22 1426
堆排序的c++代码实现，建立大根堆，然后每次利用大根堆的第一个数（最大）和最后一个叶节点交换，然后将这个叶节点从树中删去（因为已经排到了他该在位置，就是当前的还没有排序好的最大值，放在最末尾），然后利用保持大根堆特性，将头沉沉沉沉到他该在的位置，不断循环。基于大根堆的堆排序就是得到递增序列，机遇小根堆的堆排序得到就是递减序列​​​​​​​。堆排序，主要分成两步，第一步就是大根堆的建立，第二步就是不断找出最大值（体现了选择排序，为选择空间复杂度：o(1)时间复杂度：o(nlogn)上面有写，不稳定数组可实现
堆排序c/c++实现
weixin_54802873的博客
02-01 855
主要有两个步骤，一个是建堆（时间复杂度nlgn），一个是排序（时间复杂度nlgn），总的时间复杂度为nlgn,细节见代码。 以下给出下面给出从小到大排序的代码。 #include <bits/stdc++.h> using namespace std; void MinHeap(int* A,int n); void MinHeapFixUp(int* A,int i,int n); void Heapsort(int* A,int n); int main() { int A[] =
【C++代码】堆排序
Jughead
06-08 352
#include <iostream> #include <algorithm> #include <vector> #include <string> #include <cstdlib> using namespace std; // 堆排序的算法步骤 // 1、把无序数组构建成二叉堆 // 2、循环删除堆顶元素 void DownAdjust(vector<int> & vec, int parentIndex) {
数据结构与算法：12种排序全代码
qq_42667970的博客
12-13 2354
排序 文章目录排序1.冒泡排序思路：优化：交换过程：C语言代码：优化后：2.直接插入排序思路：过程：代码：3.折半插入排序折半查找代码4.希尔插入排序思路：排序过程：代码5.选择排序思路:排序过程：代码6.鸡尾酒排序法思路:代码7.堆排序思路：代码8.归并排序思路：代码9.快速排序思路：代码10.计数排序思想：代码11.桶排序思路：代码12.基数排序思路过程：代码代码 各种排序算法的时间复杂度和空...
C++数据结构输出堆排序每一趟结果
06-10
好的，以下是C++代码实现堆排序并输出每一趟结果的过程： ```c++ #include using namespace std; // 堆排序函数 void HeapSort(int arr[], int n) { // 构建初始大根堆 for (int i = n / 2 - 1; i >= 0; i--) {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yuleo_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值