数据结构：二叉树

最新推荐文章于 2022-12-02 20:22:00 发布
最新推荐文章于 2022-12-02 20:22:00 发布
阅读量307 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43665107/article/details/85099448
版权

一、树

一种非线性的数据结构，树的结点包含一个数据及若干指向子树的分支。
结点拥有的子树数称为结点的度。度为0的结点称为叶结点，度不为0的结点称为分支结点。
树的度定义为所有结点中度的最大值。
树中结点的最大层次称为树的高度或深度。

在这里插入图片描述

二、二叉树

一个根结点上最多有两个结点的树称为二叉树。

满二叉树：二叉树中所有分支结点的度数都为2，且叶结点都在同一层次上。
完全二叉树：如果一棵具有n个结点的高度为k的二叉树，它每一个结点都与高度为k的满二叉树中编号为1-n的结点一一对应，则这棵二叉树称为完全二叉树。

同样结点数的二叉树，完全二叉树的高度最小。

主要性质：
1.在二叉树的第 i 层最多有 2^(i-1) 个结点。

2.深度为k 的二叉树最多有（2^k ） - 1 个结点

3.对于任何的一棵二叉树，如果其叶结点有n0个，度为2的非叶结点有n2个，则 n0 = n2 + 1。===>n1+2n2 = n0+n1+n2-1

4.具有n 个结点的完全二叉树的高度为log2n +1

5.编号从0开始，左孩子结点的编号为2n+1,右孩子结点的编号为2n+2
编号从1开始，左孩子结点的编号为2n， 右孩子结点的编号为2n+1

BTree.h文件

#ifndef _BTREE_H_
#define _BTREE_H_

typedef enum{FALSE, TRUE}  BOOL;
typedef enum{LEFT, RIGHT}  MOUNTWAY;//挂载

typedef char  BTreeData;

typedef struct btreeNode        // 二叉树的结点
{
	BTreeData data;             // 数据
	struct btreeNode *lchild;   // 左孩子结点指针
	struct btreeNode *rchild;   // 右孩子结点指针
}BTreeNode;

typedef struct btree            // 二叉树
{
	BTreeNode *root;            // 指向根节点的指针
}BTree;

BTree*  BTree_Create();//创建树

typedef void (*PFUNC)(BTreeNode *node, int level);//函数指针
//PFUNC是一个指针变量，它指向一个函数

1、插入位置 用二进制表示路径
0 代表左 1代表右 100(4) 左左右
右左左 001(1) ===> 无法确定步数
需要另一个参数：步数 (4 3) (1, 3)

2、挂载方式
btree 要插入的二叉树
data 要插入的数据
path 插入位置的路径
steps 从根节点开始走的步数
mw 原来的结点挂载到新节点后的方式

BOOL BTree_Insert(BTree *btree, BTreeData data, int path, int steps, MOUNTWAY mw);//插入结点

void BTree_Display(BTree *btree, PFUNC callback);//打印

BOOL BTree_Delete(BTree *btree, int path, int steps);//删除结点

int BTree_Count(BTree* btree);//获取树的结点数

int BTree_Height(BTree* btree);//获取树的高度

int BTree_Degree(BTree* btree);//获取树的度
void BTree_Destroy(BTree *btree);//销毁树

#endif // _BTREE_H_BTree.h文件

BTree.c文件

 #include "BTree.h"
 #include <stdlib.h>

创建树

    BTree* BTree_Create()
    {
    	BTree* btree = (BTree*)malloc(sizeof(BTree)/sizeof(char));//申请空间
    	if (NULL == btree)
    		return NULL;
    	
    	btree->root = NULL;   // 空的树
    	
    	return btree;//返回内存地址
    }

插入结点

    BOOL BTree_Insert(BTree *btree, BTreeData data, int path, int steps, MOUNTWAY mw)
    {
    	if (NULL == btree)//入口参数检测
    		return FALSE;
    	
    	BTreeNode *node = (BTreeNode*)malloc(sizeof(BTreeNode)/sizeof(char));//申请新的结点空间
    	if (NULL == node)
    		return FALSE;
    	
    	node->data = data;//赋值
    	node->lchild = NULL;
    	node->rchild = NULL;
    	
    	BTreeNode *parent = NULL;       // 父节点
    	BTreeNode *tmp = btree->root;   // 根节点
    	
    	int way = 0;
    	while (steps>0 && tmp != NULL)//找到要插入数位置，保存要插入位置的根结点
    	{
    		way = path & 1;
    		path >>= 1;
    		
    		parent = tmp;//需要保存要插入位置根结点的值
    		if (LEFT == way)
    			tmp = tmp->lchild;
    		else
    			tmp = tmp->rchild;
    		
    		steps--;
    	}
    	
    	if(LEFT == mw)//挂载
    		node->lchild = tmp;
    	else
    		node->rchild = tmp;
    	
    	if (parent != NULL)//考虑父结点位空的情况
    	{
    		if (LEFT == way)
    			parent->lchild = node;
    		else
    			parent->rchild = node;
    	}
    	else
    		btree->root = node;//根节点的父结点为空
    	
    	
    	return TRUE;
    }

删除结点

    void r_delete(BTreeNode *node)
    {
    	if (NULL == node)
    		return;
    	
    	r_delete(node->lchild);    // 删除左结点
    	r_delete(node->rchild);    // 删除右结点
    	free(node);                // 删除自己
    }

删除结点（与插入结点类似）

    BOOL BTree_Delete(BTree *btree, int path, int steps)
    {
    	if (NULL == btree)
    		return FALSE;
    
    	BTreeNode *parent = NULL;       // 父节点
    	BTreeNode *tmp = btree->root;   // 根节点
    	
    	int way = 0;
    	while (steps>0 && tmp != NULL)
    	{
    		way = path & 1;
    		path >>= 1;
    		
    		parent = tmp;
    		if (LEFT == way)
    			tmp = tmp->lchild;
    		else
    			tmp = tmp->rchild;
    		
    		steps--;
    	}
    	
    	if (NULL != parent)
    	{
    		if (LEFT == way)
    			parent->lchild = NULL;
    		else
    			parent->rchild = NULL;
    	}
    	else
    		btree->root = NULL;
    	
    	
    	r_delete(tmp);
    	
    	return TRUE;
    }

获取树的结点：左结点数+右结点数+1（根结点）

    int r_count(BTreeNode *node)
    {
    	if (NULL == node)
    		return 0;
    	
    	int lc = r_count(node->lchild);    // 左子树的结点数
    	int rc = r_count(node->rchild);    // 右子树的结点数
    	
    	return lc+rc+1;
    }

    int BTree_Count(BTree* btree)
    {
    	if (NULL == btree)
    		return 0;
    	
    	return r_count(btree->root);
    }

获取树的高度：左子树的高度与右子树的高度中大的值+1

   int r_height(BTreeNode *node)
    {
    	if (NULL == node)
    		return 0;
    	
    	int lh = r_height(node->lchild);    // 左子树的高度
    	int rh = r_height(node->rchild);    // 右子树的高度
    	
    	return (lh>rh?lh:rh)+1;
     }
     
     int BTree_Height(BTree* btree)
        {
        	if (NULL == btree)
        		return 0;
        	
        	return r_height(btree->root);
        }

获取树的度：左子树的度与右子树的度中大的值（假如根节点的度为1时）
（这个是重点）

      int r_degree(BTreeNode *node)
        {
        	if (NULL == node)
        		return 0;
        	
        	int degree = 0;
        	if (NULL != node->lchild)
        		degree++;
        	
        	if (NULL != node->rchild)
        		degree++;
        	
        	if (1 == degree)
        	{
        		int ld = r_degree(node->lchild);    // 左子树的度
        		int rd = r_degree(node->rchild);    // 右子树的度
        		
        		if (degree < ld)
        			degree = ld;
        		if (degree < rd)
        			degree = rd;
        	}
        	
        	return degree;
        }
       
        int BTree_Degree(BTree* btree)
        {
        	if (NULL == btree)
        		return 0;
        	
            	return r_degree(btree->root);
           }

销毁树

    void BTree_Destroy(BTree *btree)
       {
             if (NULL == btree)
                	return;
                	
             r_delete(btree->root);   // 删除根节点
       	     free(btree);             // 删除树
     }

打印（运用递归的方式打印）
具体打印方式由main函数进行定义

void r_display(BTreeNode *node, PFUNC callback, int level)
{
	callback(node, level);  // 1、打印自己
	
	if (NULL == node)
	{
		return;
	}
		
	if (node->lchild != NULL || node->rchild != NULL)
	{
		r_display(node->lchild, callback, level+1);  // 2、打印左结点
		
		r_display(node->rchild,  callback, level+1);  // 3、打印右结点	
	}
}
    
void BTree_Display(BTree *btree, PFUNC callback)
{
	if (NULL == btree)
		return;
	
	r_display(btree->root, callback, 1);
}

前序遍历（递归）

void pre_order(BTreeNode* node)
{
	if (node == NULL)
		return;
	
	printf ("%4c", node->data);  // 根
	pre_order(node->lchild);     // 左
	pre_order(node->rchild);     // 右
}

中序遍历（递归）

void mid_order(BTreeNode* node)
{
	if (node == NULL)
		return;
	
	mid_order(node->lchild);     // 左
	printf ("%4c", node->data);  // 根
	mid_order(node->rchild);     // 右
}

后序遍历（递归）

void last_order(BTreeNode* node)
{
	if (node == NULL)
		return;
	
	last_order(node->lchild);     // 左
	last_order(node->rchild);     // 右
	printf ("%4c", node->data);  // 根
}

main.c文件

   #include <stdio.h>
   #include "BTree.h"
    
void myprint(BTreeNode *node, int level)//用类似于tree的方式来打印
{
	int i;
	for (i = 1; i < level; i++)
	{
		printf ("----");
	}
	
	if (node != NULL)
		printf ("%c\n", node->data);
	else
		printf ("\n");
}

    int main()
    {
    	BTree* btree = BTree_Create();
    	if (NULL == btree)
    		return -1;
    	
    	// printf ("二叉树创建成功\n");
    	
    	BTree_Insert(btree, 'A', 0, 0, LEFT);
    	BTree_Insert(btree, 'B', 0, 1, LEFT);
    	BTree_Insert(btree, 'C', 1, 1, LEFT);
    	BTree_Insert(btree, 'D', 0, 2, LEFT);
    	BTree_Insert(btree, 'E', 2, 2, LEFT);
    	BTree_Insert(btree, 'F', 1, 2, LEFT);
    	BTree_Insert(btree, 'J', 6, 3, LEFT);
    	BTree_Insert(btree, 'H', 1, 3, LEFT);
    	
    	BTree_Display(btree, myprint);
    	printf ("前序遍历： ");
    	pre_order(btree->root);
    	printf ("\n");
    	
    	
    	printf ("中序遍历： ");
    	mid_order(btree->root);
    	printf ("\n");
    	
    	printf ("后序遍历： ");
    	last_order(btree->root);
    	printf ("\n");
    	return 0;
    }

验证结果为：

在这里插入图片描述

非递归方式实现前序遍历（借助链式栈实现）

void pre1(BTreeNode *root)
{
	if(root == NULL)
		return;
	
	LinkStack *stack =  CreateStack();
	BTreeNode* p = root;
	
	while (p != NULL || !StackEmpty(stack))
	{
		while(p)
		{
			printf ("%4c", p->data);//打印
			Push(stack, p);//入栈
			p = p->lchild;//遍历左子树
		}
		
		if (!StackEmpty(stack))
		{
			Pop (stack, &p);//出栈
			p = p->rchild;//遍历右子树
		}
	}
}

非递归方式实现中序遍历 （借助链式栈来实现）

void mid1(BTreeNode *root)
{
	if(root == NULL)
		return;
	
	LinkStack *stack =  CreateStack();
	BTreeNode* p = root;
	
	while (p != NULL || !StackEmpty(stack))
	{
		while(p)
		{
			Push(stack, p);//入栈
			p = p->lchild;//遍历左子树
		}
		
		if (!StackEmpty(stack))
		{
			Pop (stack, &p);//出栈
			printf ("%4c", p->data);//打印
			p = p->rchild;//右子树遍历
		}
	}
}
weixin_43665107
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树（六）：二叉树的最大深度与最小深度
qq_42138662的博客
06-20 7091
一、二叉树的最大深度 二叉树的最大深度 二叉树的最大深度可以通过递归法，层次遍历和深度优先遍历实现，但是最简单最容易的就是递归法。 1、递归法 1）确定递归三要素 递归函数的返回值和参数：返回值为当前节点的最大深度，参数为当前节点 递归函数的单层逻辑：当前节点的最大深度 = 1 + 左子树或右子树的最大深度 递归函数的终止条件：当前节点为空时，当前节点最大深度为0 2）递归方法代码 class Solution { public: //递归参数及返回值 int maxDepth(Tre
数据结构：二叉树相关代码
最新发布
08-24
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据结构，广泛应用于算法设计、数据库系统、编译器等。这个压缩包“数据结构：二叉树相关代码”很可能包含了各种二叉树操作的实现，如插入、删除、...
【BFS&递归】求二叉树最小高度
weixin_45209148的博客
07-15 946
1.题目：求二叉树最小高度 【LeetCode111】:判断一棵二叉树的最小高度: Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Note: A leaf is a node with no children. Example 1: In
36.二叉树的最小高度（简单）
SCU-JJkinging的博客
10-23 7068
给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明：叶子节点是指没有子节点的节点。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：2 示例 2： 输入：root = [2,null,3,null,4,null,5,null,6] 输出：5 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, lef
求二叉树的最小高度
weixin_46838716的博客
05-21 4434
1）笔试面试都先用常规树形DP搞二叉树的递归套路，收集信息，整理信息，这也算是最优解了 2）Morris遍历搞这个最小高度的难度非常大，控制高度增加减少，很麻烦 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。
数据结构知识总结
撑一把纸伞，等一位佳人
10-14 639
目录二叉搜索树(BST)1. 概念2. 相应操作3. 代码实现 二叉搜索树(BST) 1. 概念 顾名思义是一棵二叉树，可能为空。 每个元素都有一个关键字，任意元素关键字不相同。 根节点的左子树，元素的关键字（如果有）都小于根节点的关键字 根节点的右子树，元素的关键字（如果有）都大于根节点的关键字 根节点的左、右子树也都是二叉搜索树 注：当关键字可重复时，定义3、4可以改为小于等于，大于等于。称为有重复值的二叉搜索树 2. 相应操作 插入 删除 查找 3. 代码实现 ..
数据结构：二叉树（链式存储）
12-07
其中，二叉树是一种非常重要的数据结构，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本主题中，我们将深入探讨如何用C语言实现链式存储的二叉树，并讨论二叉树的创建以及三种不同的...
数据结构：二叉树的应用
04-25
一、 实验目的： ...3. 按照二叉树的结构输出二叉树； 4. 三种不同遍历算法遍历此二叉树； 5. 查找某人在二叉树中的位置，要求输出从根结点至查找结点的路径； 6. 统计二叉树的深度，输出叶子结点的信息。
数据结构：二叉树链表并遍历输出
07-13
数据结构：二叉树链表并遍历输出
数据结构笔记：二叉树
01-20
分类目录——数据结构笔记 二叉树：每个节点最多含有两个子树的树称为二叉树 二叉树的性质 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 深度为k的二叉树至多有2^k-1个结点（k>0） 对于任意一棵二叉树，如果其叶...
二叉树的最小高度和最大高度
qq_33403986的博客
03-15 2354
二叉树的最小高度和最大高度的递归实现
求二叉树的最大高度与最小高度
枯木何日可逢春
07-08 1103
#include<iostream> #include<queue> using namespace std; // 二叉树的链式存储 typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; // 先序遍历创建二叉树 void CreateBiTree(BiTree &T){ char ch; cin>>ch; if(ch=='#
111. 二叉树的最小深度
jia2018的博客
02-26 62
111. 二叉树的最小深度111. 二叉树的最小深度方法一：深度优先搜索方法二：广度优先搜索 111. 二叉树的最小深度 方法一：深度优先搜索 class Solution { public int minDepth(TreeNode root) { if (root == null) { return 0; } if (root.left == null && root.right == null) {
二叉排序树_求二叉树的高度
u011925500的专栏
02-15 4264
如果定义一颗二叉树的高度就是从根到叶子的最长距离。试编码求二叉树的高度。 其实，二叉树的高度就是它的左子树和右子树中高度最大值 + 1 另外考虑: 当待排序的数据本来就是有序的情况，会发生什么？ 请参考《数据结构》教材解决这个问题。 class BiTree { private int data; private BiTree left; private Bi
二叉排序树的高度分析
weixin_34366546的博客
04-14 939
一，介绍 对于二叉排序树而言，其相关操作与树的高度息息相关。设树中有N个节点， 尽管各个操作的平均时间复杂度为O(logN)，但当输入的序列有序时，构造出来的树是一个单分支的树，其高度为O(N) 故对二叉排序树的各个操作（如，findMax、contains、findMin...）的时间复杂度也退化成O(N)    二：实现思路 现在分析给定一个输入序列，根据该输入序列构造一棵二叉排序...
二叉树的最小深度
木水先生的博客
03-23 2491
1 题目链接 二叉树的最小深度 2 题目要求 描述 求给定二叉树的最小深度。最小深度是指树的根结点到最近叶子结点的最短路径上结点的数量。 示例 输入：{1,2,3,4,5} 返回值：2 3 代码思路 法一：使用递归完成。分为三种情况：空树、左子树或右子树为空、左右子树都不为空。 如果当前树是空树，则返回高度0即可。 如果左子树或右子树为空。左子树为空时，如我们要计算{F,#,I}的最小高度，我们只需要计算右子树{I}的最小高度加上当前节点{F}的高度即可。右子树为空时，如我们要计算{C,F,#,#
计算二叉树的最小高度
雪儿的专栏
12-02 1239
c#，leetCode算法，算法
算法入门教程——二叉树
04-22
循序渐进的讲解二叉树的相关知识。其中包括二叉搜索树的插入、删除与查询、二叉树的遍历、求一颗二叉树的高度等重要且经典的知识。
数据结构：二叉树遍历详解
“这是一份关于数据结构的英文教学课件，专注于树与二叉树的第二部分，涵盖了二叉树节点的抽象数据类型（ADT）以及遍历算法，包括层次遍历、前序遍历、中序遍历和后序遍历。课件讨论了递归和非递归两种遍历算法实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值