二叉树链式结构的实现

最新推荐文章于 2024-07-07 19:21:48 发布
最新推荐文章于 2024-07-07 19:21:48 发布
阅读量744 收藏 4
点赞数 5
分类专栏： 数据结构（初阶） 文章标签： 二叉树 遍历 节点计数 高度计算 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmz123_/article/details/121056763
版权

文章目录

二叉树的遍历

为了先了解二叉树的结构，此处先手动快速创建一棵简单的二叉树：
在这里插入图片描述

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	node->_data = x;
	node->_left = NULL;
	node->_right = NULL;
}

BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode('A');
	BTNode* node2 = BuyNode('B');
	BTNode* node3 = BuyNode('C');
	BTNode* node4 = BuyNode('D');
	BTNode* node5 = BuyNode('E');
	BTNode* node6 = BuyNode('F');
	BTNode* node7 = BuyNode('G');

	node1->_left = node2;
	node1->_right = node3;
	node2->_left = node4;
	node3->_left = node5;
	node3->_right = node6;
	node4->_left = node7;
	return node1;
}

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

前序遍历

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	printf("%c ", root->_data);
	PreOrder(root->_left);
	PreOrder(root->_right);
}

前序遍历递归图解：
在这里插入图片描述

中序遍历：

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->_left);
	printf("%c ", root->_data);
	InOrder(root->_right);
}

后序遍历

void PostOrder(BTNode* root)
{
	if (root == NULL) {
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%c ", root->data);
}

测试结果：
在这里插入图片描述

节点个数及高度等

求二叉树节点个数

核心思想：节点个数=1+左子树节点个数+右子树节点个数

int BinaryTreeSize(BTNode* root)
{
	return root==NULL?0:1
		+BinaryTreeSize(root->_left)
		+ BinaryTreeSize(root->_right);
}

求二叉树叶子节点个数

int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	else if (root->_left == NULL && root->_right == NULL)
		return 1;
	else
		return BinaryTreeLeafSize(root->_left)
		+ BinaryTreeLeafSize(root->_right);
}

求二叉树第k层节点个数

核心思路：当前树的第k层节点个数=当前树的左子树的第k-1层个数+当前树的右子树的第k-1层个数

int BinaryTreeLeavelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;
	else if (k == 1)
		return 1;
	else
		return BinaryTreeLeavelKSize(root->_left,k-1)
		+ BinaryTreeLeavelKSize(root->_right,k-1);
}

求二叉树深度/高度

核心思想：当前树的深度=max(左子树深度，右子树深度)+1

int BinaryTreeDepth(BTNode* root)
{
	if (root == NULL)
		return 0;
	
	//先给两个变量存储结果，若直接放到return就得算两次
	int leftDepth = BinaryTreeDepth(root->_left);
	int rightDepth = BinaryTreeDepth(root->_right);

	return leftDepth > rightDepth?leftDepth+1:rightDepth+1;
}

查找值为x的节点

  1. 先判断是不是当前节点，是就返回
  2. 不是就先去左树找，找到了就返回
  3. 左树没找到，再去右树找。
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)
		return left;
	BTNode* right = BinaryTreeFind(root->_right, x);
	if(right)
	return right;

	return NULL;
}

二叉树基础oj练习

分治：大问题分成小问题，小问题再继续分，直到分割成不可再分割的子问题。

单值二叉树

题目描述：如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。只有给定的树是单值二叉树时，才返回true，否则返回false
在这里插入图片描述

思路：

  1. ==具有传递性
  2. a == b && a == c
  3. b == e && b == f
  4. 即a跟e和f相等。
bool isUnivalTree(struct TreeNode* root){
    if(root==NULL)
        return true;
    if(root->left && root->val != root->left->val)
        return false;
    if(root->right && root->val != root->right->val)
        return false;
    
    return isUnivalTree(root->left) 
    && isUnivalTree(root->right);
}

其中if(root->left && root->val != root->left->val) &&两边不能调换，否则如果root->left为空，但却已经进行了两个值的比较，会报错。

二叉树的前序遍历

题目描述：给你二叉树的根节点root，返回它节点值的前序遍历

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int TreeSize(struct TreeNode* root)
{
    if(root==NULL)
        return 0;
    return 1+TreeSize(root->left)+TreeSize(root->right);
}

void _preorderTraversal(struct TreeNode* root,int* arr,int* pi)
{
    if(root==NULL)
        return;

    arr[(*pi)++]=root->val;
    _preorderTraversal(root->left,arr,pi);
    _preorderTraversal(root->right,arr,pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    *returnSize=TreeSize(root);
    int* arr=(int*)malloc(sizeof(int)* *returnSize);
    int i=0;
    _preorderTraversal(root,arr,&i);
    return arr;
}

注意： 在void _preorderTraversal中，最后一个参数要传的是指针。每个递归调用栈帧中都有一个i，下一层++i，不会对上一次影响。但是我们想要的是只有一个i作为下标++

相同的树

题目描述：给你两棵二叉树的根节点p和q，编写一个函数来检验这两棵树是否相同。如果两个数在结构上相同，并且节点具有相同的值，则认为它们是相同的。
在这里插入图片描述

要比较两棵树是否相同，就要比较两棵树的根节点和各自的左子树和右子树是否相同。

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    if(p==NULL && q==NULL)
        return true;
    if(p==NULL || q==NULL)
        return false;
    if(p->val!=q->val)
        return false;
        
    return isSameTree(p->left,q->left)
        && isSameTree(p->right,q->right);
}
  • 时间复杂度：O(N)
  • 空间复杂度：O(h）-> 最坏情况 O(N) 完全二叉树或满二叉树h=logN

对称二叉树

题目描述：给定一个二叉树，检查它是否是镜像对称的。
在这里插入图片描述

要判断是否对称，首先判断根节点是否为空，再判断根节点的左右子树是否对称，递归。

bool _isSymmetric(struct TreeNode* p, struct TreeNode* q)
{
    if(p==NULL && q==NULL)
        return true;
    if(p==NULL || q==NULL)
        return false;
    if(p->val!=q->val)
        return false;
        
    return _isSymmetric(p->left,q->right)
        && _isSymmetric(p->right,q->left);
}

bool isSymmetric(struct TreeNode* root){
    if(root==NULL)
        return true;
    
    return _isSymmetric(root->left,root->right);      
}

另一棵树的子树

题目描述：给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。
二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。
在这里插入图片描述

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root==NULL)
        return false;
    if(isSameTree(root,subRoot))
        return true;
    return isSubtree(root->left,subRoot)
        || isSubtree(root->right,subRoot);
}

二叉树的创建和销毁

通过前序遍历的数组构建二叉树

问题描述：编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。
在这里插入图片描述

struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* CreatTree(char* str,int* pi)
{
    if(str[*pi]=='#')
    {
        (*pi)++;
        return NULL;
    }
    
    struct TreeNode* root=(struct TreeNode*)
        malloc(sizeof(struct TreeNode));
    root->val=str[(*pi)++];
    root->left=CreatTree(str, pi);
    root->right=CreatTree(str, pi);
    
    return root;
}

void InOrder(struct TreeNode* root)
{
    if(root==NULL)
        return;
    InOrder(root->left);
    printf("%c ",root->val);
    InOrder(root->right);
}
int main()
{
    char str[100];
    scanf("%s",str);
    int i=0;
    struct TreeNode* root=CreatTree(str, &i);
    InOrder(root);
    return 0;
}

二叉树销毁

//二叉树销毁
void BinaryTreeDestroy(BTNode* root)
{
	if (root == NULL)
		return;

	BinaryTreeDestroy(root->_left);
	BinaryTreeDestroy(root->_right);
	free(root);
}

层序遍历

用队列实现二叉树的层序遍历。先把第一次（根）放入队列。上一层出队，带入下一层。

//层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%c ", front->_data);
		if (front->_left)
		{
			QueuePush(&q,front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
	}
	printf("\n");
	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;
		}
		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;
}

测试结果：
在这里插入图片描述

ymz123_
关注
专栏目录
数据结构10——二叉树链式结构的实现
cainiaochufa2021的博客
06-21 1089
我们知道二叉树有两种存储表示方式：1.数组结构；2. 链式结构。 数组表示法用于完全二叉树的存储非常有效，但表示一般二叉树，特别是形态剧烈变化的，存储空间的利用不是很理想。使用链式结构表示，可以克服这些缺点。 这一节介绍二叉树链式结构的实现以及二叉树常见的一些基础问题。......
【数据结构】二叉树链式结构的遍历（前序、中序、后序、层序遍历）
zhao_leilei的博客
06-21 1652
所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。前、中、后序遍历均采用递归操作： 1.前序遍历 根节点->根节点的左子树->根节点的右子树 递归实现： void PreOrder(BTNode* root) { if (root) { printf("%d ", root->data); PreOrder(root->left); PreOrder(root->right);
【数据结构】二叉树链式结构实现_BiTreeLink
博客
11-14 4981
#include "string.h" #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE
数据结构：二叉树的链式结构及代码实现
最新发布
cbwjty的博客
07-07 787
在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。注意：上面的代码不是真正创建二叉树的代码 ，真正的创建二叉树的代码在后面重点讲解。再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：：根结点，根结点的左子树、根结点的右子树组成的。
二叉树的链式实现
不忘初心
10-24 635
#include #include struct treenode{ int element; struct treenode* left; struct treenode* right; };
数据结构：二叉树的链式存储实现
憧憬，思考，奋斗，飞翔
05-08 2661
/*********************************************************************************** 程序：二叉树的链式存储实现 作者：小单 完成时间:2013年4月25日 *****************************************************************
二叉树链式结构的主要实现
wrf228的博客
03-27 736
空树（空结点）由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
02二叉树链式结构实现_BiTreeLink.c
05-16
02二叉树链式结构实现_BiTreeLink.c
二叉树链式存储结构代码实现
qq_42430426的博客
07-23 5201
上一篇博客已经介绍过实际内容了，这一篇直接上干货代码了。 结构体 前面写的是用c语言写的，用的也是递归的方法 typedef char BTDataType; typedef struct BTNode { struct BTNode* left; struct BTNode* right; BTDataType data; }BTNode; 1、创建二叉树 typedef struct ...
JAVA 实现二叉树（链式存储结构）
09-02
在本文中，我们将探讨如何使用Java来实现一个二叉树，采用的是链式存储结构。 首先，我们来看链式存储结构在二叉树中的应用。链式存储结构是通过节点间的引用或指针连接各个节点，而不是像顺序存储结构那样使用数组...
数据结构与算法：（4）二叉树的遍历
CAOJUN_FANG的博客
09-16 340
1、简介 二叉树是一种非常重要的数据结构，在许多算法中我们需要使用到二叉树来解决问题。掌握二叉树的遍历对解决后续的算法问题显得非常有必要，常见的二叉树遍历方法分为深度遍历 和 广度遍历 两种。其中深度遍历包含前序、中序、后序三种遍历方法，广度遍历也称为层次遍历。 遍历思想： 前序遍历：根节点 －－－＞左子树－－－＞右子树 中序遍历：左子树－－－＞根节点－－－＞右子树 后序遍历：左子树－－－＞右子树－－－＞根节点 广度遍历（层次遍历）：根节点 －－－＞左子树－－－＞右子树 2、实现 定义二叉树： publ
数据结构：二叉树的链式存储
weixin_30416497的博客
11-15 452
数据结构：二叉树的链式存储（C语言版） 1.写在前面 　　数组表示的优势和弊端 　　二叉树同样有两种存储方式，数组和链式存储，对于数组来说，我们利用二叉树的性质然后利用下标可以方便的找到一个节点的子节点和父节点。 　　　　 　　 二叉树的性质: 　　1.二叉树的第i层上至多有2i-1个节点 　　2.深度为K的二叉树至多有2k-1个节点 　　3.任何一个二叉树中度...
二叉树实现（链表实现）
小青头的博客
04-17 1079
二叉树链表实现 node.h #pragma once #ifndef NODE_H_ #define NODE_H_ class Node { public: Node(); Node *SearchNode(int nodeIndex); void DeleteNode(); void PreorderTraversal(); void InorderTraversal(); v...
数据结构—二叉树链式结构的实现
weixin_42357849的博客
04-19 801
一.二叉树的链式结构。 二叉树的链式存储结构是指用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。 链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链。 二.链式结构的实现。 1.二叉树管理: 节点管理： #define BSTDataType int...
【数据结构】二叉树链式结构的实现
weixin_47132900的博客
09-09 824
二叉树的遍历： 所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。
数据结构之二叉树——链式存储结构（php代码实现）
weixin_34417183的博客
01-30 126
<?php /** *ClearBiTree()清空二叉树 *CreateBiTree()创建二叉树 *BiTreeEmpty()判断二叉树是否为空 *BiTreeDepth()返回二叉树的深度 *root()返回二叉树的根 *Parent()返回给定元素的双亲 *LeftChild()要返回左孩子的元素 *RightChi...
二叉树的链式存储实现
m0_53591689的博客
06-28 149
1
二叉树的链式存储——深入了解数据结构代码篇（二）
aruewds的博客
04-16 244
一、关键 需要一个左指针和右指针 层序遍历需要队列辅助。每访问一个队头元素，将该元素的左指针和右指针加入其中（如果有的话）。 寻找前驱，其实和普通遍历方式一致，不过visit函数修改，变为判断是否找到当前元素，是则返回前驱；否则继续寻找。这里采用全局变量的方式，返回final，pre是前驱，p是需要找的元素。 二、代码 2.1 结构体定义 typedef int ElemType; typedef struct BitNode { ElemType data; struct BitNod
【数据结构】链式二叉树结构的实现
weixin_52843203的博客
11-16 1722
前言 二叉树不同于顺序表，一颗普通的二叉树是没有增删改查的意义。普通的二叉树用来存储数据是不方便的。但是二叉树的一些基本实现结构，例如前序遍历，中序遍历。。。等等都是对我们学习更深层次的二叉树打下夯实的基础。 二叉树节点声明 typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType data; struct BinaryTreeNode* left; struct BinaryTreeNode* right;.
C语言实现二叉树链式存储及操作
"这篇资源是关于C语言中二叉树链式存储的实例教程，提供了创建、遍历、计算深度、节点数、叶子数等基本操作的代码实现。通过输入不同的字符指令，用户可以执行相应的操作，如创建二叉树、计算高度、查找特定值的节点...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值