数据结构-二叉树详解

最新推荐文章于 2023-03-24 09:24:06 发布

写完这行就睡觉

最新推荐文章于 2023-03-24 09:24:06 发布

阅读量977

点赞数 3

文章标签：数据结构算法

本文链接：https://blog.csdn.net/m0_62918577/article/details/128496313

版权

一.二叉树

1.概念及结构

一棵二叉树是结点的一个有限集合，该集合:
1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
3. 二叉树不存在度大于2的结点
4. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

2.特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

3.性质与解题

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：是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否则无右孩子

对于3这种结论对有些题目非常有用。

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）
A 不存在这样的二叉树
B 200
C 198
D 199

ps: n2=199,n0=200

4.存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
1）顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

性质：（逻辑结构与存储结构的对应）

2）链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链。

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pParent; // 指向当前节点的双亲
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}；

二.顺序结构与堆

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储。那什么是堆？

1.堆的概念及结构

堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树，堆只有大堆或者小堆没有其他种类。

下面以小堆为例，讲解堆的创建，插入及删除等。

2.堆的创建

在堆的创建前需要先掌握两个算法：

1）堆向下调整算法

算法前提：一个数组，逻辑上看做一颗完全二叉树，加上根节点整体不是小堆。但根节点的左右子树都是小堆。算法用于调整数组使得整体是小堆。

过程：将根节点以及它的两个节点值比较，若根节点为最小（因为是构建小堆）则算法结束。

否则将三者里的最小者与根节点交换（数组里是将两个值交换），交换以后重复此过程直到根节点没有子节点。

2）堆向上调整算法

算法前提：一个数组，逻辑上看做一颗完全二叉树，加上最后一个节点整体不是小堆。但去掉该节点的树都是小堆。算法用于调整数组使得整体是小堆。

过程：将最后的节点以及它的父亲节点值比较，若该节点更大（因为是构建小堆）则算法结束。

否则将父亲节点与该节点交换（数组里是将两个值交换），交换以后重复此过程直到该节点到达根节点。

有了上述的两个算法，针对任意数组都可以分别采用两种算法实现调整数组顺序使之成为小堆。

第一种：从倒数第一个非叶子节点开始从后往前依次对每个节点进行向下调整，直到根节点。时间复杂度：O(N)

第二种：从第一个节点开始从前往后依次对每个节点进行向上调整，直到最后一个节点。时间复杂度： O(N*logN)

3.堆的插入

将插入的数据加入到数组最后一位，然后进行向上调整。详见2里的向上调整算法。

4.堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

5.堆的具体实现

//大堆的具体实现
typedef int HeapDataType;
typedef struct Heap
{
	HeapDataType* p;
	int size;
	int capcity;
}Heap;

void HeapInit(Heap* ph);
void HeapPush(Heap* ph, HeapDataType x);
void HeapPop(Heap* ph);
void HeapDestory(Heap* ph);
void HeapPrint(Heap* ph);
bool HeapEmpty(Heap* ph);
int HeapSize(Heap* ph);

void AdjustUp(HeapDataType* p, int index);
void AdjustDown(HeapDataType* p, int size, int index);


// 堆的构建
void HeapCreate1(Heap* ph, HeapDataType* a, int n);
void HeapCreate2(Heap* ph, HeapDataType* a, int n);

void HeapInit(Heap* ph)
{
	assert(ph);
	ph->capcity = ph->size = 0;
	ph->p = NULL;
}
void Swap(HeapDataType* p1, HeapDataType* p2)
{
	HeapDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}


void AdjustUp(HeapDataType* p, int index)
{
	int child = index;
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (p[child] < p[parent])
		{
			break;
		}
		else
		{
			Swap(&p[child], &p[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
	}
}

void HeapPush(Heap* ph,HeapDataType x)
{
	assert(ph);
	if (ph->capcity == ph->size)
	{
		int newcapcity = ph->capcity == 0 ? 4 : ph->capcity * 2;
		HeapDataType* tmp = (HeapDataType*)realloc(ph->p,sizeof(HeapDataType) * newcapcity);
		if (!tmp)
		{
			perror("realloc fail!\n");
			exit(-1);
		}
		ph->capcity = newcapcity;
		ph->p = tmp;
	}
	ph->p[ph->size++] = x;
	AdjustUp(ph->p, ph->size - 1);
	
}
void AdjustDown(HeapDataType* p, int size,int index)
{
	int parent = index;
	int child = parent * 2 + 1;
	//大堆
	while (child < size)
	{
		if (child + 1 < size && p[child + 1] > p[child])
		{
			child++;
		}
		if (p[parent] > p[child])
		{
			break;
		}
		else
		{
			Swap(&p[child], &p[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
	}
}
void HeapPop(Heap* ph)
{
	assert(ph);
	Swap(&ph->p[0], &ph->p[ph->size-1]);
	ph->size--;

	AdjustDown(ph->p, ph->size, 0);
	
}


void HeapDestory(Heap* ph)
{
	assert(ph);
	free(ph->p);
	ph->p = NULL;
	ph->size = ph->capcity = 0;
}

void HeapPrint(Heap* ph)
{
	for (int i = 0; i < ph->size; i++)
	{
		printf(FORMAT, ph->p[i]);
	}
	printf("\n");
}

bool HeapEmpty(Heap* ph)
{
	return ph->size == 0;
}
int HeapSize(Heap* ph)
{
	assert(ph);
	return ph->size;
}



void HeapCreate1(Heap* ph, HeapDataType* a, int n)
{
	//不断push，向上调整 O(N*logN)
	HeapDataType* p = (HeapDataType*)malloc(sizeof(HeapDataType) * n);
	if (p == NULL)
		exit(-1);
	ph->p = p;
	ph->size = 0;
	ph->capcity = n;
	for (int i = 0; i < n; i++)
	{
		ph->p[ph->size] = a[i];
		AdjustUp(ph->p, ph->size);
		ph->size++;
	}
	
}
void HeapCreate2(Heap* ph, HeapDataType* a, int n)
{
	//不断pop，向下调整  O(N)
	HeapDataType* p = (HeapDataType*)malloc(sizeof(HeapDataType) * n);
	if (p == NULL)
		exit(-1);
	ph->p = p;
	ph->size = n;
	ph->capcity = n;
	memcpy(ph->p, a, sizeof(HeapDataType) * n);
	for (int i = (n-2)/2; i >= 0; i--)
	{
		AdjustDown(ph->p,n, i);
	}
	
}

6.堆的应用：堆排序和OPK问题

1）推排序

将要排序的数据放入数组然后传入数组和数据个数，进行堆的构建，每次的堆根节点为最值，将最值交换到最后（此时的堆范围少1），再排序如此重复直到排完所有数据。一般使用向下调整，时间复杂度为O（N）。

//堆排序(PS大堆实现升序)
void Heapsort(int* a, int n)
{
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	while (n > 1)
	{
		Swap(&a[0], &a[n - 1]);
		n--;
		AdjustDown(a, n, 0);
	}
}

2）TOPK问题（选出所有数据里的前k个最大值或最小值）

与堆排序一样只是在排k次选出k个最值后就可以停下。

三.链式二叉树

1.前序/中序/后序遍历

二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

// 二叉树前序遍历 
void BTPreOrder(BTNode* root)
{
	if (root == NULL)
		return;
	printf("%d ", root->val);
	BTPreOrder(root->left);
	BTPreOrder(root->right);
}
// 二叉树中序遍历
void BTInOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BTInOrder(root->left);
	printf("%d ", root->val);
	BTInOrder(root->right);
}

// 二叉树后序遍历
void BTPostOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BTPostOrder(root->left);
	BTPostOrder(root->right);
	printf("%d ", root->val);
}

2.层序遍历

还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

实现流程：


// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q,root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* ret = QueueFront(&q);
		QueuePop(&q);
		if(ret->left)
		QueuePush(&q, ret->left);
		if (ret->right)
		QueuePush(&q, ret->right);/*
		printf("%d\n", QueueSize(&q));*/
		printf(FORMAT, ret->val);
	}
	printf("\n");
	QueueDestroy(&q);

}

拓展：判断二叉树是否是完全二叉树

利用层序遍历，及时孩子是空也入栈，当队首取到空时检查此时栈是否全为空的元素，否则不是完全二叉树。


// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{

	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* ret = QueueFront(&q);
		QueuePop(&q);
		if (ret == NULL)
			break;
		QueuePush(&q, ret->left);
		QueuePush(&q, ret->right);
		
	}
	if (!QueueEmpty(&q))
	{
		BTNode* ret = QueueFront(&q);
		if (ret)
		{/*
			QueueDestroy(&q);*/
			return false;
		}
	}

	//QueueDestroy(&q);
	return true;
}

3.结点个数高度等递归


// 二叉树节点个数
int BTSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	return BTSize(root->left) + BTSize(root->right)+1;
}

// 二叉树叶子节点个数
int BTLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return BTLeafSize(root->left) + BTLeafSize(root->right);
}

// 二叉树第k层节点个数
int BTLevelSize(BTNode* root,int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return BTLevelSize(root->left, k - 1) + BTLevelSize(root->right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root)
	{
		if (root->val == x)
		{
			return root;
		}
		else
		{
			BTNode* l= BinaryTreeFind(root->left, x);
			if (l)
				return l;
			else
				return BinaryTreeFind(root->right, x);
		}
	}
	else
	{
		return NULL;
	}
}

4.创建与销毁

通过前序遍历的一串字符串构建出链式的二叉树结构。

a为字符串的数组，n为字符个数，pi代表遍历到的下标i的地址。

传入整形数组也可以：（0代表为NULL）


// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi) 
{
	if (a[*pi] == 0 || *pi >= n)
	{
		(*pi)++;
		return NULL;
	}
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	if (root)
	{

		root->val = a[*pi];
		(*pi)++;
		root->left = BinaryTreeCreate(a, n, pi);
		root->right = BinaryTreeCreate(a, n, pi);
		return root;
	}
	else
		exit(-1);

}


//销毁二叉树
void BinaryTreeDestory(BTNode** root)
{
	assert(root);
	if (*root)
	{
		BinaryTreeDestory(&(*root)->left);
		BinaryTreeDestory(&(*root)->right);
		free(*root);
		*root = NULL;
	}
}

写完这行就睡觉

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
数据结构-二叉树详解

一.二叉树.概念及结构，.特殊的二叉树，二叉树的性质以及利用性质解题，利用顺序结构构建的二叉树与堆，.堆的概念及结构，堆的创建.堆的插入，堆的删除，堆的具体实现，堆的应用：堆排序和OPK问题。链式二叉树1.前序/中序/后序遍历2.层序遍历创建与销毁
复制链接

扫一扫