数据结构之二叉树(C语言版)

最新推荐文章于 2024-08-14 11:39:25 发布
最新推荐文章于 2024-08-14 11:39:25 发布
阅读量614 收藏 30
点赞数 18
分类专栏： 数据结构笔记(C语言版) 文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A2885A/article/details/141004448
版权

前言

各位读者朋友们大家好，上期我们讲了数据结构的堆以及建堆算法，这期我们主要来讲一下数据结构的二叉树，这部分内容对于C语言的函数递归有比较多的应用，因此难度也比较大，我们一一来讲解。

目录

一. 树的基本概念

在讲二叉树之前我们先讲一下树的基本概念：树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
在这里插入图片描述

  • 节点的度： 一个节点含有的子树的个数；如上图A节点的度为3。
  • 叶节点或终端节点： 度为0的节点；如上图的J、K、L。
  • 非终端节点或分支节点： 度不为0的节点；如上图的B、C 、D等。
  • 父节点或双亲节点：若一个节点有子节点，那么该节点就称为其子节点的父亲节点；如上图的A、B、G等。
  • 子节点：根节点的子节点；上图除A节点外都是子节点。
  • 兄弟节点：具有相同的父亲节点的节点；如上图中的E和F、H和I是兄弟节点。
  • 树的度：一棵树中，最大的结点的度称为树的度 ，上图中树的度是3。
  • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推。
  • 树的高度或深度：树中节点的最大层次，；上图中树的高度为4。

二. 树的表示方法

因为树是一种非线性的数据结构，所以存储表示起来很复杂，既要存值域，又要存节点与节点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
左孩子右兄弟表示法：

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

在这里插入图片描述

三. 二叉树的概念及结构

二叉树是一种非线性数据结构，是一种一个父亲节点最多有两个子节点的树。
在这里插入图片描述
在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树。
特殊的二叉树：

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

四. 二叉树的性质

  • 1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2i-1个节点。
  • 2. 若规定根节点的层数为1，则深度为h的二叉树最多有2h-1个节点。在这里插入图片描述
  • 3. 对于任何一棵二叉树，如果度为0的叶节点个数为n0，度为2的分支节点个数为n2，则n0 = n2+1。在这里插入图片描述
  • 4. 若规定根节点的层数是1，具有n个结点的满二叉树深度，h=log2(n+1)。

五. 二叉树的基础操作

5.1二叉树的创建

我们定义二叉树的结构：

typedef int BTDataType;
typedef struct BTreeNode
{
	BTDataType val;
	struct BTreeNode* left;
	struct BTreeNode* right;
}BTNode;

现在我们手搓这棵二叉树
在这里插入图片描述

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	node->val = x;
	node->left = node->right = NULL;
	return node;
}
BTNode* BTCreat()
{
	BTNode* n1 = BuyNode(1);
	BTNode* n2 = BuyNode(2);
	BTNode* n3 = BuyNode(3);
	BTNode* n4 = BuyNode(4);
	BTNode* n5 = BuyNode(5);
	BTNode* n6 = BuyNode(6);
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n4->left = n5;
	n4->right = n6;
	return n1;
}

5.2 二叉树的遍历

5.2.1 前序遍历

前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。

void PrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->val);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

我们看一下递归展开图来理解一下：
在这里插入图片描述
在这里插入图片描述

5.2.2 中序遍历

中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}

我们看一下递归展开图来理解一下：
在这里插入图片描述

5.2.3 后序遍历

后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

void AfterOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	AfterOrder(root->left);
	AfterOrder(root->right);
	printf("%d ", root->val);
}

我们看一下递归展开图来理解一下：
在这里插入图片描述

5.3 求二叉树结点的个数

int TreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return 1 + TreeSize(root->left) + TreeSize(root->right);
}

这里的思路跟前序遍历差不多，1代表每棵树的根节点，然后再访问左子树和右子树,最后将左右子树的节点求和即可。

5.4 求二叉树叶子结点的个数

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

在这里插入图片描述

5.5 求二叉树的高度

要求二叉树的高度即求左右子树的高度然后取最大值再加上根节点即可。

我们先看一下代码：

int TreeDepth(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int left = TreeDepth(root->left);//提高效率
	int right = TreeDepth(root->right);
	return left > right ? left + 1 : right + 1;
}

借助递归展开图来理解一下：
在这里插入图片描述

5.6 求二叉树第K层结点的个数

在二叉树中，第一层只有一个节点，我们要求第K层的节点个数，我们可以将第K层的每一个节点看作第一层的节点然后再将这些节点的个数加起来即可

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

5.7 在二叉树中找值为X的节点

我们在二叉树中找值为X的节点并能将其返回，思路就是先遍历左子树，如果左子树找到的话就直接返回节点的地址，如果找不到就遍历右子树，找到的话就返回对应节点的地址，如果左右子树都没找到就返回NULL,当树是空树的情况下也返回NULL。

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->val == x)
	{
		return root;
	}
	BTNode* left = NULL;
	left = TreeFind(root->left, x);
	if (left)
	{
		return left;
	}
	BTNode* right = NULL;
	right = TreeFind(root->right, x);
	if (right)
	{
		return right;
	}
	//没找到
	return NULL;
}

5.8 二叉树的销毁

对于二叉树的销毁，我们可以采用后序遍历那样的思路来实现，我们将二叉树分为左子树、右子树和根，先销毁左子树和右子树最后销毁根，把根放在最后销毁是为了便于通过根来找到后面的节点。

void BTDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	BTDestory(root->left);
	BTDestory(root->right);
	free(root);
}

六. 二叉树的层序遍历

层序遍历（level-order traversal）从二叉树的顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。
层序遍历本质上属于广度优先遍历（breadth-first traversal），也称广度优先搜索（breadth-first search, BFS），它体现了一种“一圈一圈向外扩展”的逐层遍历方式。
在这里插入图片描述
层序遍历的实现要借助队列来实现。在根节点出队列的同时，其对应的子节点入队列。

void TreeLeverOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)//非空入队列
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);//取队列的头元素
		QueuePop(&q);
		printf("%d ", front->val);
		if (root->left)
			QueuePush(&q, front->left);//非空左子树入队列
		if (root->right)
			QueuePush(&q, front->right);//非空右子树入队列
	}
}

七. 判断是不是完全二叉树

这里我们的思路是将二叉树的根节点入队列，在节点出队列的同时不管子节点是否为空都将其子节点代入到队列中，当我们出到第一个空节点时，看队列中是否还有非空节点，如果有就不是完全二叉树，反之则是。
在这里插入图片描述
这里不必担心有非空节点入不进去的情况，在第一个非空节点出队列之前所有影响判断的节点都已经入队列了，即使有非空节点没有入队列也不会影响判断结果。

bool TreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if(root)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))//队列出到空
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//队列出到第一个空节点
		if(front == NULL)
			break;
		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;
}

结语

这期我们就讲完了二叉树的基本内容，希望对大家有所帮助，欢迎大家批评指正！

跃渊Yuey
关注
  • 18
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——二叉树高度（C语言）
aaa946231的博客
01-24 3857
求给定二叉树的高度。函数接口定义：int GetHeight( BinTree BT ); 其中BinTree结构定义如下：typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType Data; BinTree Left; BinTree Right; }
数据结构之树和二叉树算法实现（C语言）
Jooey_Zhong
10-26 5389
待我学有所成，结发与蕊可好。@夏瑾墨 开发环境为Dev-C++ 5.11 编译器：MinGW GCC 6.1.0 64-bit 一、算法程序组建目录结构如下： 第一部分：头文件 1. c1.h 2. c3-3.h 3. c6-1.h 4. c6-2.h 5. c6-3.h 6. c6-4.h 7. c6-5.h 8. c6-7.h 第二部分：主程序入口文
数据结构入门-C语言实现二叉树
JiajunBernoulli的博客
05-11 891
定义 typedef int DataType; typedef struct Node{ DataType data; struct Node *LChild; struct Node *RChild; }BiTNode,*BiTree; 创建 void CreateBiTree(BiTree *T) { char ch; scanf("%c",&ch); if(ch ==...
数据结构与算法（C语言） | 树和二叉树 （二）二叉树
Shannon
08-09 3512
二叉树的定义： 二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 二叉树与树的区别：     二叉树不是树的特殊情形，而是与树不同的数据结构，即二叉树并不等价于2 度的树。 1)一个二叉树中可以不存在度为2的结点。（不是都需要两棵子树，而是最多可以是两棵，没...
数据结构之二叉树（C语言附详细代码）
热门推荐
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
数据结构-二叉树（c语言）
胖大xian
05-28 285
一下代码是二叉树的相关代码、包括二叉树的根据前序遍历创建二叉树。根据前序遍历、中序遍历与后续遍历依次查找二叉树的各个节点。 #include<stdio.h> //定义二叉树节点数据类型 typedef struct bitnode { int data; //存储数据结点 struct bitnode *left, *right; //存储该结点的左右子树指针 } bitnode, *bitree; //bitree为指向
C语言数据结构二叉树
m0_51579489的博客
04-09 800
#include<stdio.h> #include<stdlib.h> #include<math.h> typedef char elemtype; typedef struct BiNode { elemtype data; struct BiNode* lchild, * rchild; }BiNode,*BiTree; typedef struct tag { BiTree p; struct tag* next; }tag_t,...
数据结构二叉树，c语言简单实现
01-12
数据结构中的二叉树是一种非线性数据结构，它由n（n>=1）个有限节点组成，这些节点通过边连接形成一个具有层次关系的集合。每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的概念在计算机科学中广泛...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
C语言数据结构实现二叉树的建立与遍历.cpp
04-18
C语言数据结构实现二叉树的建立与遍历.cpp
《数据结构》（C语言版）教程
10-14
《数据结构》（C语言版）教程是一门深入学习计算机科学与技术不可或缺的重要课程，它主要探讨如何在计算机中组织和存储数据，以便高效地访问和处理这些数据。本教程结合了C语言这一强大而灵活的编程语言，使得学生...
数据结构之二叉树c语言代码
12-22
一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者最后一层是满的，或者是在右边缺少连续若干结点...
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
最新发布
sjsjs11的博客
08-14 197
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
C语言实现排序之快速排序算法
2403_83044722的博客
08-14 282
快速排序（Quick Sort）是一种非常高效且实用的排序算法，它采用分治法（Divide and Conquer）的思想来完成排序。
常见8种数据结构
qq_43575301的博客
08-08 2157
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 636
双向链表的创建，插入，遍历，删除
数据结构--第六天
xujiashuo1的博客
08-08 1376
树是由。
Redis 支持的五种主要数据结构
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
08-09 5829
Redis，作为一个高性能的键值对数据库，不仅支持简单的字符串类型数据，还提供了丰富的数据结构来满足各种复杂场景的需求。
数据结构--双指针与LeetCodeHOT100
wumingzei的博客
08-09 962
在编程和算法设计中，双指针技术是一种常用且强大的工具。它涉及使用两个指针在数据结构上进行操作，以解决特定的问题。双指针技术常见于数组、链表、字符串等数据结构的处理中，尤其在处理需要在数据集合中进行遍历、搜索和排序的场景时表现出色。双指针是一种算法策略，它使用两个游标（或索引）来遍历或操作数据结构中的元素。这两个指针可以以不同的速度移动，或者从不同的起点开始，以实现不同的算法目标。
数据结构平衡二叉树C语言代码
07-16
当然，下面是一个简单的平衡二叉树的C语言代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构 typedef struct Node { int data; // 节点值 struct Node* left; // 左子节点指针 struct Node* right; // 右子节点指针 int height; // 节点高度 } Node; // 计算节点的高度 int height(Node* node) { if (node == NULL) { return 0; } return node->height; } // 获取两个数中较大的值 int max(int a, int b) { return (a > b) ? a : b; } // 创建一个新节点 Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->left = NULL; newNode->right = NULL; newNode->height = 1; return newNode; } // 执行右旋操作 Node* rightRotate(Node* y) { Node* x = y->left; Node* T2 = x->right; x->right = y; y->left = T2; y->height = max(height(y->left), height(y->right)) + 1; x->height = max(height(x->left), height(x->right)) + 1; return x; } // 执行左旋操作 Node* leftRotate(Node* x) { Node* y = x->right; Node* T2 = y->left; y->left = x; x->right = T2; x->height = max(height(x->left), height(x->right)) + 1; y->height = max(height(y->left), height(y->right)) + 1; return y; } // 获取节点的平衡因子 int getBalanceFactor(Node* node) { if (node == NULL) { return 0; } return height(node->left) - height(node->right); } // 插入节点 Node* insertNode(Node* node, int data) { if (node == NULL) { return createNode(data); } if (data < node->data) { node->left = insertNode(node->left, data); } else if (data > node->data) { node->right = insertNode(node->right, data); } else { // 忽略插入相同的节点 return node; } node->height = 1 + max(height(node->left), height(node->right)); int balanceFactor = getBalanceFactor(node); // 左-左情况，执行右旋操作 if (balanceFactor > 1 && data < node->left->data) { return rightRotate(node); } // 右-右情况，执行左旋操作 if (balanceFactor < -1 && data > node->right->data) { return leftRotate(node); } // 左-右情况，先对左子节点进行左旋，再对当前节点进行右旋 if (balanceFactor > 1 && data > node->left->data) { node->left = leftRotate(node->left); return rightRotate(node); } // 右-左情况，先对右子节点进行右旋，再对当前节点进行左旋 if (balanceFactor < -1 && data < node->right->data) { node->right = rightRotate(node->right); return leftRotate(node); } return node; } // 中序遍历二叉树 void inorderTraversal(Node* root) { if (root != NULL) { inorderTraversal(root->left); printf("%d ", root->data); inorderTraversal(root->right); } } int main() { Node* root = NULL; root = insertNode(root, 10); root = insertNode(root, 20); root = insertNode(root, 30); root = insertNode(root, 40); root = insertNode(root, 50); root = insertNode(root, 25); printf("中序遍历结果："); inorderTraversal(root); return 0; } ``` 这段代码实现了一个平衡二叉树的插入和中序遍历操作。你可以根据需要自行修改和扩展。希望对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值