数据结构二叉树（C语言）

最新推荐文章于 2025-12-26 16:25:00 发布

原创最新推荐文章于 2025-12-26 16:25:00 发布 · 1.1k 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

一.树的相关概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
树形结构中，子树之间不能有交集。

根节点：没有前驱结点的节点，如A

节点的度：一个节点含有的子树的个数，如A的度为6

叶节点（终端节点）：度为0的节点，如B，H

双亲节点（父节点）：含有子节点的节点，如D,E

孩子节点（子节点）：如H是D的孩子节点

兄弟节点：具有相同父节点的节点互称为兄弟节点如B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度如上图：树的度为6

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推
树的高度或深度：树中节点的最大层次；如上图：树的高度为4
节点的祖先：从根到该节点所经分支上的所有节点；如A是所有节点的祖先

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如所有节点都是A的子孙

树的表示：孩子兄弟表示法

typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
}

实际应用于文件系统的目录树结构

二.二叉树概念及结构

1.概念

一棵二叉树是结点的一个有限集合

二叉树是：1. 空树

2. 非空：根节点，根节点的左子树、根节点的右子树组成的。

二叉树不存在度大于2的节点

2.特殊的二叉树

满二叉树：每一层的节点数都是满的（每个父节点都有两个孩子节点）的二叉树

如果一个满二叉树层数为K，他的节点总数为2^K-1

完全二叉树：假设层数为h，前h-1层都是满的，最后一层要求是从左到右连续（不能有空，如下图）最后一层节点最少为一个，总节点数量范围[2^(h-1),2^h-1]

3.二叉树的性质

1.对任何一棵二叉树, 如果度为0其叶结点个数为a, 度为2的分支结点个数为b,则有a＝ b＋1

(度为0永远比度为2多一个节点）

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

3.若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2^h -1

具有n个结点的满二叉树的深度，h=log2(n+1)

4.二叉树的值在数组位置父子的下标表示：

parent=(child-1)/2; leftchild=parent*2+1; rightchild=parent*2+2;

三.堆的介绍及实现

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

1.概念及结构

概念：将一堆元素以完全二叉树的顺序存储方式存储进数组，如果每个父亲节点都大于等于儿子节点，则称为大（根）堆，反之都小于等于，称为小（根）堆。

堆的结构：

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

2.堆向下调整算法

前提：左右子树都是堆

主要用于删除堆顶元素或堆的构建时

思路：

计算当前节点（parent）的左子节点索引（child = parent * 2 + 1）。
比较左右子节点（若右子节点存在且更大，选择右子节点作为比较对象）。
比较父节点与选中的子节点（大堆中若子节点更大，则交换）。
交换后，将子节点作为新的父节点，重复上述过程，直到子节点超出堆的范围（child < n 不成立）或满足堆性质。

3.向上调整算法

前提：除了child这个位置，其余都构成堆

主要用于插入元素时。

思路：

计算当前节点（child）的父节点索引（parent = (child - 1) / 2）。
比较子节点与父节点的值（大堆中若子节点更大，则交换）。
交换后，将父节点作为新的子节点，重复上述过程，直到子节点到达根节点（child > 0 不成立）或满足堆性质。

4.堆的创建

升序建大堆降序建小堆

每次将堆顶元素与堆的最后一个元素交换，再对从最后一个非叶子节点开始做向下调整。

void Heapsort(int* a, int n)
{
	//先建堆
	//排升序 建大堆
	//for (int i = 1; i < n; ++i)
	//{
	//	AdjustUp(a, i);
	//}//向上调整建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)//从最后一个节点的父亲开始调整那棵子树
	{
		AdjustDown(a, n, i);
	}//向下调整建堆
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0);
		--end;
	}
}

5.topK问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大

思路：

1. 用数据集合中前K个元素来建堆

前k个最大的元素，则建小堆

前k个最小的元素，则建大堆

2.用剩余的N-K个元素依次与堆顶元素来比较，如果比堆顶数据大（小堆）则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最大/小的元素。

6.堆的模拟实现

#define _CRT_SECURE_NO_WARNINGS
#include"heap.h"
#include<stdio.h>
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
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 = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}
void AdjustDown(HPDataType* a, int n, int parent)
{
	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 HeapInit(Heap* hp)
{
	assert(hp);
	hp->a=(HPDataType *)malloc(sizeof(HPDataType)*4);
	if (hp->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	hp->size = 0;
	hp->capacity = 4;
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
    assert(hp);
	free(hp->a);
	hp->a = NULL;
    hp->size=hp->capacity=0;
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	if (hp->capacity == hp->size)
	{
		HPDataType* tmp = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * hp->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		hp->a = tmp;
		hp->capacity *= 2;
	}
	hp->a[hp->size++] = x;
	AdjustUp(hp->a, hp->size - 1);
}
// 堆的判空
bool HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size == 0;
}
// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;
	AdjustDown(hp->a, hp->size, 0);
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	return hp->a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}

四.二叉树介绍及实现

1.二叉树的结构

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

2.二叉树的遍历

前序遍历：根左子树右子树，输出123456

中序遍历：左子树根右子树，输出321546

后序遍历：左子树右子树根，输出325641

层序遍历：一层一层遍历，即输出124356

前序遍历递归图

3.二叉树模拟实现

主要思想：递归分治

注：

根的第K层个数=左子树的第K-1层个数+右子树的K-1层个数

当前树的高度=左右子树中高度高的那一个+1

判断是否为完全二叉树：按层序走，非空节点一定连续

#define _CRT_SECURE_NO_WARNINGS
#include"tree.h"
#include"queue.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a,int* pi)
{
	if (a[*pi] == '#') return NULL; 
	BTNode* root =(BTNode*)malloc(sizeof(BTNode));
	root->data = a[(*pi)++];
	root->left = BinaryTreeCreate(a, pi);
	root->right= BinaryTreeCreate(a, pi);
	return root;
}
// 二叉树销毁
void BinaryTreeDestroy(BTNode** root)
{
	if (root == NULL)return;
	BTNode* new = *root;
	BinaryTreeDestroy(&new->left);
	BinaryTreeDestroy(&new->right);
	free(new);
	*root = NULL;
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)return 0;
	return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)return 0;
	if (root->left == NULL && root->right == NULL)return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)return 0;
	if (k == 1)return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)return NULL;
	if (root->data == x)return root;
	BTNode* left = BinaryTreeFind(root->left, x);
	if (left != NULL)return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	if (right!= NULL)return right;
	return NULL;
}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)return ;
	printf("%d", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)return;
	BinaryTreeInOrder(root->left);
	printf("%d", root->data);
	BinaryTreeInOrder(root->right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)return;
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%d", root->data);
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{ 
		QueuePush(&q, root);
		while (!QueueEmpty(&q))
		{
			BTNode* front = QueueFront(&q);
			QueuePop(&q);
			printf("%d", front->data);
			if (front->left) QueuePush(&q, front->left);
			if (front->right) QueuePush(&q, front->right);
		}
	}
	QueueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
		while (!QueueEmpty(&q))
		{
			BTNode* front = QueueFront(&q);
			QueuePop(&q);
			if (front == NULL)break;
			else
			{
				QueuePush(&q, front->left);
				QueuePush(&q, front->right);
			}
		}
		while (!QueueEmpty(&q))
		{
			BTNode* front = QueueFront(&q);
			QueuePop(&q);
			if (front)
			{
				QueueDestroy(&q);
				return false;
			}
			QueueDestroy(&q);
			return true;
		}
	}
}