二叉树（堆，链式二叉树）

最新推荐文章于 2024-09-28 20:44:11 发布
最新推荐文章于 2024-09-28 20:44:11 发布
阅读量934 收藏 9
点赞数 30
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gokku/article/details/138920260
版权

一.二叉树的概念和结构

 . 一棵二叉树是一格有限个节点的集合，或者为空，或者由根节点和其左子树和右子树组成。

1.空树

.空树是指一个不包含任何节点的树结构,也就是说它没有任何分支和叶子节点。

2.普通二叉树

注：①不存在度为2的节点；

       ②左右子树不可颠倒顺序，因此二叉树是有序树。 

3.满二叉树和完全二叉树

①满二叉树，该树的每一层的节点数都达到了最大值，若一棵树的层数为k，则该二叉树的总节点数为2^k-1个。

 ②完全二叉树，假设该树有k层，则该树的前k-1层是满的，第k层节点从左到右连续，其第k层最少有一个节点，最多有2^(k-1)个节点，由此看来，满二叉树是一种特殊的完全二叉树。

4.二叉树的性质

1）若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1）个结点.
2）若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h-1.
3）对任何一棵二叉树，如果度为0其叶结点个数为n0，度为2的分支结点个数为n2，则有n0=n2+1 4）若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1).(ps：log2(n+1)是log以2为底，n+1为对数)
5）对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对
于序号为i的结点有： 

1）若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点2.若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子3.若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

二.二叉树的顺序存储-堆 

1.堆的概念

.二叉树的顺序存储适用于完全二叉树，其空间在物理上是连续的，在逻辑上是非连续的是一颗完全二叉树，称之为堆。堆又分为小堆和大堆，小堆是父节点里的值小于等于左右孩子，大堆则相反。

2.堆的实现（以小堆为例）

 1）定义堆的结构

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<time.h>
#include<stdbool.h>
typedef int HPDataType;
//堆的物理结构是顺序表，逻辑结构是二叉树
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

2）堆的初始化和销毁

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
}

3）往堆里插入元素

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//先扩
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("failed realloc");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;
	AdjustUp(php->a, php->size-1);
}

注：这里在插入前，首先要检查是否需要扩容，防止空间不够。其次，这里建堆使用了向上调整算法，可以保证堆里的元素保持大堆或小堆结构。

-->向上调整算法

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
		}
		child = parent;
		parent = (parent - 1) / 2;
	}
}

4）删除堆里的一个元素（默认删除堆顶元素）

void HeapPop(HP* php)
{
	//删除堆顶的元素
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);

}

-->向下调整算法

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
    //谨防a[child+1]越界
	while (parent < size && child+1 < size )
	{
		if (a[child] > a[child + 1])
		{
			child += 1;
		}
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
		}
		parent = child;
		child = parent * 2 + 1;
	}
}

5）返回堆的大小，判空，返回堆顶元素

int  HeapSize(HP* php)
{
	assert(php);
	return php->size;
}
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
HPDataType HeapTop(HP* php)
{
	assert(php);
	return php->a[0];
}

3.堆的实际应用

1）TopK求解

  即从庞大的数据里筛选出前K个最大或最小的数据。找大值，建小堆，凡是遇到比堆顶大的就替换掉堆顶，并向下调整，保证小堆的结构，越大的值，越会沉底。同样的，找小值，建大堆。

void HeapTopK(int k)
{
	//不支持变长数组，只能malloc
	HPDataType* min_heap = (HPDataType*)malloc(sizeof(HPDataType) * k);
	if (min_heap == NULL)
	{
		perror("failed malloc");
		exit(-1);
	}
	HPDataType* a = (HPDataType*)malloc(sizeof(HPDataType) * 1000);
	if (a == NULL)
	{
		perror("failed malloc");
		exit(-1);
	}
	srand(time(0));
	for (int i = 0; i < 1000; i++)
	{
		a[i] = (rand() + i) % 1000;
	}
	a[993] = 1011111;
	a[823] = 100021;
	a[523] = 100031;
	a[223] = 100011;
	a[123] = 100041;
	//往数组放数据
	for (int i = 0; i < k; i++)
	{
		min_heap[i] = a[i];
	}

	//向下调整建堆,从最后一个非叶子节点
	for (int i = (k -1 -1)/2; i >= 0 ; i--)
	{
		AdjustDown(min_heap,k, i);
	}
	//将剩余数据与堆顶比较
	int x = 0;
	while (x<1000)
	{
		if (a[x] > min_heap[0])
		{
			min_heap[0] = a[x];
			AdjustDown(min_heap, k, 0);
		}
		x++;
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", min_heap[i]);
	}
	printf("\n");
	free(min_heap);
}

注：这里人为的存入5个值，方便进行测试。 

2)堆排序

void HeapSort(int* a,int n)
{
	//建大堆，排升序
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
    for (int i = 0; i < n; i++)
    {
    	printf("%d ", a[i]);
    }
    printf("\n");
	int end = n - 1;
	while (end >= 0)
	{
		Swap(&a[0], &a[end]);
		//先调整，此时end刚好是正确的个数，保证是大堆
		AdjustDown(a, end, 0);
		end--;

	}
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

注：依次将堆顶值（即为最大的值），与堆尾交换，并pop删除一个元素，并进行向下调整，保证次大的值到堆顶。

三.二叉树的链式结构 

.链式二叉树，是由一个个节点相互搭建而成，每一个节点包括有效值和左孩子和右孩子的指针。

 1）定义节点的结构

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int BTreeDataType;
typedef struct BTreeNode
{
	BTreeDataType val;
	struct BTreeNode* left;
	struct BTreeNode* right;
}Node;

2）手动造一棵二叉树，方便进行遍历

Node* BuyNode()
{
	Node* tmp =(Node*)malloc(sizeof(Node));
	tmp->left = NULL;
	tmp->right = NULL;
	return tmp;
}
Node* BuyTree()
{
	Node* node1 = BuyNode();
	Node* node2 = BuyNode();
	Node* node3 = BuyNode();
	Node* node4 = BuyNode();
	Node* node5 = BuyNode();
	Node* node6 = BuyNode();
	node1->val = 1;
	node2->val = 2;
	node3->val = 3;
	node4->val = 4;
	node5->val = 5;
	node6->val = 6;
	node1->left = node2;
	node1->right = node3;
	node2->left = node4;
	node2->right = node5;
	node3->left = node6;
	return node1;
}v

3）二叉树的遍历

①深度优先遍历（递归写法）：前序遍历，中序遍历，后序遍历

->前序遍历（问题分治：根 左子树 右子树，返回条件：遇到空就返回）

->中序遍历（问题分治：左子树 根 右子树，返回条件：遇到空就返回）

->后序遍历（问题分治：左子树 右子树 根 ，返回条件：遇到空就返回） 

void PreOrder(Node* root)
{
	if (root == NULL)
		return;
	printf("%d ", root->val);
	PreOrder(root->left);
	PreOrder(root->right);
}
void MidOrder(Node* root)
{
	if (root == NULL)
		return;
	MidOrder(root->left);
	printf("%d ", root->val);
	MidOrder(root->right);
}
void BackOrder(Node* root)
{
	if (root == NULL)
		return;
	BackOrder(root->left);
	BackOrder(root->right);
	printf("%d ", root->val);
}

 

②广度优先遍历：层序遍历

利用队列先进先出的特性，每入一个元素，在删除它后，把它的左右子孩子放到队列中去（孩子为空不入队列），直到队列为空。

void LeavelOrder(Node* root)
{
	Queue queue;
	QueueInit(&queue);
	if(root)
		QueuePush(&queue,root);
	while (!QueueEmpty(&queue))
	{
		Node* front = QueueFront(&queue);
		printf("%d ", front->val);
		//每出一个元素，将它的左孩子和右孩子带进去
		QueuePop(&queue);
		//孩子不为空才入队列
		if (front->left)
			QueuePush(&queue, front->left);
		if (front->right)
			QueuePush(&queue, front->right);
	}
	QueueDestroy(&queue);
}

 

->拓展1：分层打印

只需加入 LevelSize变量，不断--，打印每一层数据，打印完一层后，刷新LevelSize的大小

//分层打印
void LeavelOrder1(Node* root)
{
	Queue queue;
	QueueInit(&queue);
	if (root)
		QueuePush(&queue, root);
	int LeavelSize = 1;
	while (!QueueEmpty(&queue))
	{
		while (LeavelSize--)
		{
			Node* front = QueueFront(&queue);
			printf("%d ", front->val);
			//每出一个元素，将它的左孩子和右孩子带进去
			QueuePop(&queue);
			//孩子不为空才入队列
			if (front->left)
				QueuePush(&queue, front->left);
			if (front->right)
				QueuePush(&queue, front->right);
		}
		printf("\n");
		LeavelSize = QueueSize(&queue);
	}
	QueueDestroy(&queue);
}

->拓展2：判断一颗树是否为完全二叉树

依据完全二叉树的结构特点，只需要在入队列时，将空指针也入进去，当不断删除队列元素，走到第一个空指针时，如果队列后面全是空指针，则为完全二叉树，反之，有别的有效地址，既不是完全二叉树。

}
//判断是否是完全二叉树
bool isComBTree(Node* root)
{
	Queue queue;
	QueueInit(&queue);
	if (root)
		QueuePush(&queue, root);
	while (QueueFront(&queue) != NULL)
	{
		Node* front = QueueFront(&queue);
		//printf("%d ", front->val);
		//每出一个元素，将它的左孩子和右孩子带进去
		QueuePop(&queue);
		//空也入队列
	/*	if (front == NULL)
			break;*/
		if (front)
		{
			QueuePush(&queue, front->left);
			QueuePush(&queue, front->right);
		}
		
	}
	while (!QueueEmpty(&queue))
	{
		if (QueueFront(&queue))
		{
			QueueDestroy(&queue);
			return false;
		}
		QueuePop(&queue);
	}
	QueueDestroy(&queue);
	return true;
}

 4）求二叉树的节点数

.分治：节点数 = 1 + 左子树节点数 + 右子树节点数；返回条件：遇到空指针返回，最终返回1+左子树节点数 + 右子树节点数。

//树的节点个数 分治：1+左子树节点数+右子树节点数
int NodeSize(Node* root)
{
	return root == NULL ? 0 : NodeSize(root->left) + NodeSize(root->right) + 1;
}

5）求叶子节点数

.分治：左子树节点数＋右子树节点数；返回条件：遇到空，返回0，遇到，叶子返回1，最终返回左子树加右子树。

int LeaftSize(Node* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return LeaftSize(root->left)+ LeaftSize(root->right);
}

 6）求树的高度（后序遍历的思想）

.分治：不断比较左子树和右子树的高度，返回高度高的；返回条件：遇到空返回0，最后返回较深子树的深度加1。

//树的高度 后序的思想
int DeepTree(Node* root)
{
	if (root == NULL)
		return 0;
	int LeftDeep = DeepTree(root->left);
	int RightDeep = DeepTree(root->right);
	return LeftDeep > RightDeep ? LeftDeep + 1 : RightDeep + 1;
}

注：这里最好定义left和right变量，用来记录数据，否则重复调用同一个函数的次数会太多，时间效率会降低。 

7）第k层节点数  

.分治：k-1层左子树，右子树的节点数,直到k到达第一层；返回条件：遇空返回0，k为1返回1。

int KNodeSize(Node* root,int k)
{
	assert(k > 0);
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return KNodeSize(root->left, k - 1) + KNodeSize(root->right, k - 1);
}

8）查找为x的节点（前序遍历思想）

.分治：根 左子树 右子树；返回条件：遇到空返回NULL，遇到val为x的节点，返回该节点的地址，遍历完所有节点都没有val为x的节点，则返回空。

//找值为x的节点
Node* FindXNode(Node* root,int x)
{

	if (root == NULL)
		return NULL;
	if (root->val == x)
		return root;
	//左子树不为空才走
	if (root->left)
		return FindXNode(root->left, x);
	//右子树不为空才走
	if (root->right)
		return FindXNode(root->right, x);
	return NULL;
}

四.小结

  二叉树分为物理空间上连续存储的堆，和由一个个节点构成的链式二叉树。堆有着TopK和堆排序的实际应用，其中向上调整算法和向下调整算法是堆学习的关键。而对于链式二叉树，更要理解消化这里递归的思想，尤其是前中后序的遍历，其中递归的思想需要不断练习相关习题才能参透。

Gokku
关注
C语言 二叉树的链式存储实例
12-31
二叉树的链式存储 实现二叉树的基本操作：建立、遍历、计算深度、结点数、叶子数等。 输入C，先序创建二叉树，#表示空节点； 输入H：计算二叉树的高度； 输入L：计算二叉树的叶子个数； 输入N：计算二叉树节点总个数...
二叉树的链式存储结构二叉树的链式存储结构
10-26
在实际应用中，二叉树的链式存储结构常用于构建二叉堆、AVL树、红黑树等自平衡二叉搜索树，这些数据结构在性能优化和算法实现中扮演着重要角色。 总结来说，二叉树的链式存储结构利用指针链接各个节点，方便了节点...
数据结构：二叉树的链式结构
Yikefore的博客
06-03 5859
链式二叉树创建非常详细的过程：包含如何前序遍历创建二叉树、对二叉树的前、中、后序遍历、二叉树节点个数、二叉树叶子节点个数、二叉树的高度、第k层节点个数、查找节点、层序遍历、判断二叉树是否为完全二叉树、二叉树的销毁.....附带完整代码以及图解
二叉树的链式存储
hellolde的博客
08-16 4192
二叉树的链式存储： 二叉树的链式存储就是二叉树中每个结点都用一个链表中的一个链结点来存储。不同的结点结构可以构成不同的链式结构。 根据二叉树的定义可知，二叉树的一个结点由一个数据元素和分别指向其左、右孩子的两个分支构成，那么用来表示二叉树结点的链结点至少应该包含3个域：数据域和左、右指针域，这种存储方式称为二叉链表链表的头指针指向二叉树的根结点。 有时，为了便于找到结点的双亲，还可以在结点中增加一个指向其父结点的域，这种结构称为三叉链表。 二叉树的二叉链表存储表示为： typedef struct B.
二叉树的链式存储结构
qq_52208569的博客
04-12 1433
文章目录前言正文总结 前言 上一节讲了二叉树的顺序存储，通过学习你会发现，其实二叉树并不适合用数组存储，因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或多会存在空间浪费的现象。本节我们学习二叉树的链式存储结构。 正文 图 1 普通二叉树示意图 如图 1 所示，此为一棵普通的二叉树，若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储即可。因此，图 1 对应的链式存储结构如图 2 所示： 图 2 二叉树链式存储结构示意图 由图 2 可知，采用链式存储二叉..
二叉树的链式结构的实现
想要上进的coder的博客
12-05 1774
一、手动创建一颗树
二叉树——链式存储结构
qq_61580414的博客
06-25 1135
二叉树可用顺序方式存储，也可使用链式存储，本关使用二叉树的链式存储方式。本关任务：在完成第一关的基础上，编写一个函数，能计算一棵二叉树中树叶的个数并输出。这段程序实现了二叉树的创建和三种遍历方式（先根遍历、中根遍历和后根遍历）的功能。创建二叉树时，可采用递归算法，其中一种方法是，将二叉树先扩充为扩二叉树，然后。这段程序的功能是创建一个二叉树，并计算该二叉树中叶子节点的个数。本关任务：编写一个能计算二叉树中有两个孩子的满结点个数。本关任务：实现二叉树的创建函数及二叉树的遍历函数。
二叉树（链式存储）
qq_43906881的博客
10-07 2036
二叉树（链式存储） 1、树数据结构与数组和链表的区别 数组存储方式的分析 优点： 通过 下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点： 如果要检索具体某个值，或者插入值( 按一定顺序) 会整体移动，效率较低 链式存储方式的分析 优点： 在一定程度上对数组存储方式有优化(比如： 插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。 缺点： 在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历） 树存储方式的分析
二叉树链式存储详解
猪肉炖粉条的博客
04-08 2089
二叉树是数据结构中一个非常重要的概念，它广泛应用于各种算法和程序设计中。在C语言中，我们可以使用链式存储的方式来实现二叉树。
数据结构-链式二叉树
m0_61433144的博客
08-02 2480
对于那些非完全二叉树，由于顺序存储结构的空间利用率低，因此二叉树一般都采用链式存储结构，用链表结点来存储二叉树中的每一个结点。在链式二叉树中，结点结构通常包括数据域和若干个指针域。......
（数据结构）二叉树的链式存储结构
热门推荐
weixin_51927215的博客
03-29 1万+
二叉树的顺序存储的缺点 因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象 图 1 普通二叉树的转化 如上图 1，普通二叉树里只有二个元素，最好的存储方式当然是开辟相对应的空间，但是顺序存储结构却让我们不能这么做！也就是说我们此时必须花更多的空间去存储相对少的元素 二叉树的链式存储 先慢慢介绍一下链式存储的节点结构！！！ 图 2 普通二叉树示意图 如上图 2 所示，若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储 因
[数据结构]二叉树的链式结构
qq_59456417的博客
11-19 1659
二叉树的链式结构，实现其前序、中序、后序及层序等一些二叉树的操作函数。
JAVA 实现二叉树（链式存储结构）
09-02
在本文中，我们将探讨如何使用Java来实现一个二叉树，采用的是链式存储结构。 首先，我们来看链式存储结构在二叉树中的应用。链式存储结构是通过节点间的引用或指针连接各个节点，而不是像顺序存储结构那样使用数组...
二叉树的链式存储.py
10-26
二叉树的链式存储 二叉树的链式存储.py二叉树的链式存储.py二叉树的链式存储.py
二叉树(线索二叉树、链式二叉树、有序二叉树) 常见操作代码实现
04-08
内容概要：用c代码完成链式二叉树、有序二叉树、线索二叉树的的常见操作。其中包括构建、销毁、前序/后序/中序遍历、高度、密度、添加、删除、查询等操作 适合人群：具备一定编程基础，尤其是c语言基础，并很好地...
【数据结构】排序算法系列——归并排序（附源码+图解）
Skrrapper的博客
09-24 1081
它的特点在于并不是一开始就将整个数组进行归类和调整，而是以一定的间隔数分成多次小的排序，最后再逐渐将小的排序的范围变大，最后变大到整个数组时，已经完全有序。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。界定比较的数据个数：一般按照2的倍数增长：两个互相比较、四个互相比较、八个互相比较…总的来说，分治法也可以被称作一种算法，它是一种基于递归的、“分而治之”的算法思想。3.合并这些子问题的解成原问题的解。
【数据结构初阶】排序算法(中)快速排序专题
最新发布
fhvyxyci的博客
09-28 649
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 771
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
哈希表(HashMap、HashSet)
wuweixiaoyue的博客
09-28 420
是个存储结构：可以让我们一次从表中直接拿到想要的元素，时间复杂度为O(1)为什么能实现O(1)：通过哈希(散列)方法，使元素的存储位置和它的关键码之间建立一一映射的关系如果想要存取元素，都是利用哈希(散列)方法 + 关键码，从而计算出index位置，然后进行操作（怎么放的就怎么给它取出来哈希函数示例：此时写着容量是1000，但实际上是2次幂数，容量为1024。
C++实现链式存储二叉树详解
"C++实现二叉树的链式存储，使用了顺序栈（SqStack）作为辅助数据结构" 在C++编程中，实现二叉树的链式存储是一种常见的数据结构操作。链式存储允许我们通过指针链接节点来构建二叉树，而不是依赖于数组的索引位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值