树和二叉树和堆之间的关系

憧憬成为原神糕手

已于 2024-07-15 11:17:58 修改

阅读量890

点赞数 10

文章标签：数据结构算法

于 2024-06-11 19:56:24 首次发布

本文链接：https://blog.csdn.net/be_a_big_cattle/article/details/139606872

版权

4.二叉树链式结构（二叉树是树的一种形式）

1.树的解释

结点的度：一个结点含有的子树的个数称为该结点的度；如上图：A的为6.
叶结点或终端结点：度为0的结点称为叶结点；如上图：B、C、H、I...等结点为叶结点
非终端结点或分支结点：度不为0的结点；如上图：D、E、F、G...等结点为分支结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点
兄弟结点：具有相同父结点的结点互称为兄弟结点；如上图：B、C是兄弟结点
树的度：一棵树中，最大的结点的度称为树的度；如上图：树的度为6
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
树的高度或深度：树中结点的最大层次；如上图：树的高度为4
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；

typedef int DataType;
struct Node
{
struct Node* Child1; // 孩子
struct Node* Brother; // 兄弟
DataType data; // 结点中的数据
};

树的结构例子：

2.二叉树（一种特殊的树）

1.满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。

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

1.二叉树的性质：

1. 若规定根结点的层数为1，则一棵非空二叉树的第h层上最多有 2^(h-1)个结点.
2. 若规定根结点的层数为1，则深度为h的二叉树的最大结点数是 s^h - 1.

3. 对任何一棵二叉树, 如果度为0其叶结点个数为 X , 度为2的分支结点个数为 Y ,则有 X＝ Y＋1
4. 若规定根结点的层数为1，具有n个结点的满二叉树的深度，h= 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.堆的性质：

1.堆中某个结点的值总是 不大于或不小于其父结点的值；
2.堆总是一棵完全二叉树。

小堆：大堆：

2. 堆的应用

2.1 堆排序
1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序

4.二叉树链式结构（二叉树是树的一种形式）

两种二叉树：
1. 空树
2. 非空：根结点，根结点的左子树、根结点的右子树组成的。

1.二叉树的遍历

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

例子一.

2. 层序遍历

层序遍历：首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
比如

下面为实现代码：

5.实现二叉树的代码：

typedef int BTDataType;
//树结构
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
//建立一个节点
BTNode* BuyNode(int k)
{
	BTNode* cur = (BTNode*)malloc(sizeof(BTNode));
	if (cur == NULL)
	{
		perror("malloc fail");
		exit(0);
	}
	cur->_data = k;
	cur->_left = cur->_right = NULL;
}
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* arr, int sz, int* i)
{
		if (arr[*i] == '#')
		{
			(*i)++;
			return NULL;
		}
		BTNode* cur = (BTNode*)malloc(sizeof(BTNode));
		cur->_data = arr[(*i)++];
		cur->_left = BinaryTreeCreate(arr, sz,i);
		cur->_right = BinaryTreeCreate(arr, sz,i);
		return cur;
}
//也可以自己手动弄一颗树，
BTNode* CreatBinaryTree()
{
		BTNode* node1 = BuyNode(1);
		BTNode* node2 = BuyNode(2);
		BTNode* node3 = BuyNode(3);
		BTNode* node4 = BuyNode(4);
		BTNode* node5 = BuyNode(5);
		BTNode* node6 = BuyNode(6);
		node1->_left = node2;
		node1->_right = node4;
		node2->_left = node3;
		node4->_left = node5;
		node4->_right = node6;
		return node1;
}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}
	printf("%c ", root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}
	BinaryTreePrevOrder(root->_left);
	printf("%c ", root->_data);
	BinaryTreePrevOrder(root->_right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
	printf("%c ", root->_data);
}


// 二叉树销毁
void BinaryTreeDestory2(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeDestory2((root)->_left);
	BinaryTreeDestory2((root)->_right);
	free(root);
	root = NULL;
}

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

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

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (k == 1)
		return 1;
	int cur = BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
	return cur;
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->_data == x)
		return root;
	BTNode* cur = BinaryTreeFind(root->_left,x);
	if (cur != NULL)
		return cur;
	BTNode* cur2 = BinaryTreeFind(root->_right, x);
	if (cur2 != NULL)
		return cur2;
	return NULL;
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
 {
	Queue q1;
	QueueInit(&q1);
	if(root)
	QueuePush(&q1, root);
	while (!QueueEmpty(&q1))
	{
		BTNode* node = QueueFront(&q1);
		QueuePop(&q1);
		printf("%d ", node->_data);
		if(node->_left)
		QueuePush(&q1, node->_left);
		if(node->_right)
		QueuePush(&q1, node->_right);

	}
	QueueDestroy(&q1);
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	Queue q1;
	QueueInit(&q1);
	if(root)
	QueuePush(&q1, root);
	while (!QueueEmpty(&q1))
	{
		BTNode* node = QueueFront(&q1);
		QueuePop(&q1);
	
		if (node == NULL)
		{
			break;
		}
		//printf("%d ", node->_data);
		QueuePush(&q1, node->_left);
		QueuePush(&q1, node->_right);
	}

	while (!QueueEmpty(&q1))	
	{
		BTNode* node = QueueFront(&q1);
		if (node != NULL)
			return false;
		QueuePop(&q1);
	}
	QueueDestroy(&q1);
	return true;
}

6.堆的实现：



//写一个交换数的代码
void swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}
//向上调整法
void adjustup(HPDataType*a , int size)
{
	int son = size-1;
	int father = (son - 1) / 2;
	while (father >= 0)
	{
		if (a[father] > a[son])
		{
			swap(&a[father], &a[son]);
			son = father;
			father = (son - 1) / 2;
		}
		else {
			break;
		}
	}
}
//向下调整法  把大的往上调

void adjustdown(HPDataType* a,int size,int parent)
	int child = 2 * parent + 1;
	while (child < size)
	{
		if (a[child + 1] > a[child] && child +1 < size)//child +1 < size 没考虑
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else {
			break;
		}
	}

}
//向下调整法  把小的往上调
void adjustdown2(HPDataType* a, int size, int parent)
{
	int child = 2 * parent + 1;

	while (child < size)
	{
		if (a[child + 1] < a[child] && child + 1 < size)//child +1 < size 没考虑
		{
			++child;//选小的
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else {
			break;
		}
	}

}

//初始化    
void HeapInit(Heap* hp)
{
	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->_a);
}
// 堆的数据个数    
int HeapSize(Heap* hp)
{
	return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
	if (HeapSize(hp) == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	assert(hp->_size);
	return hp->_a[0];
}

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	if (hp->_size == hp->_capacity)
	{
		int newcapacity = hp->_capacity == 0 ? 4 : 2 * sizeof(hp->_capacity);
		HPDataType* tmp = (HPDataType*)realloc(hp->_a,sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		hp->_a = tmp;
		hp->_capacity = newcapacity;
	}
	hp->_a[hp->_size] = x;
	hp->_size++;
	adjustup(hp->_a, hp->_size);

}
// 堆的删除
void HeapPop(Heap* hp)
{
	swap(&hp->_a[0], &hp->_a[hp->_size-1]);
	hp->_size--;
	adjustdown2(hp->_a, hp->_size,0);
}

//下面为 堆的排序
//降序: 小堆
void HeapSort1(int* a, int sz)
{

	for (int i = 1; i <= sz; i++)// 建小堆的方法
	{
		adjustup(a, i);//把小的往上调，建小堆
	}
    //把最小的放后面
	int end = sz - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		adjustdown2(a, end, 0);
		end--;
	}
}
	//升序： 大堆
void HeapSort2(int* a, int sz)
{

	for (int i = (sz - 2) / 2; i >= 0; i--)//建大堆的方法
	{
		adjustdown(a, sz, i);    //把大的往上调，建大堆
	}
    //把最大的放到最后面
	int end = sz - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		adjustdown(a, end, 0);
		end--;
	}
}

憧憬成为原神糕手

关注

10
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
树和二叉树和堆之间的关系

一个结点含有的子树的个数称为该结点的度；如上图：A的为6.：度为0的结点称为叶结点；如上图：B、C、H、I...等结点为叶结点：度不为0的结点；如上图：D、E、F、G...等结点为分支结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点：具有相同父结点的结点互称为兄弟结点；如上图：B、C是兄弟结点：一棵树中，最大的结点的度称为树的度；如上图：树的度为6。
复制链接

扫一扫