数据结构｜二叉树

已于 2023-04-17 12:52:59 修改
阅读量128 收藏
点赞数 1
分类专栏： 笔记 文章标签： 数据结构 算法 c语言
于 2023-04-10 17:17:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53157551/article/details/130039534
版权

目录


写在前面

  • 本以为这二叉树有什么难的，无非就是几个定义，然后把前中后序遍历搞清楚就行了，然后还有几个满二叉树，完全二叉树的定义。在老师持续输出了几天后发现脑子根本跟不上，二叉树难的是用非递归实现，难的是用学过的栈、队列，与二叉树联合起来，用不同的方法实现算法。老师把我按在地上摩擦，不写点笔记复习一下真的懂不了。

二叉树的定义

二叉树由左子树，右子树以及数据构成，每一层节点数达到最大值称为满二叉树，最后一层从右向左依次缺省节点的树称为完全二叉树。
二叉树的定义：

typedef char ElemType;
typedef struct BTNode{
	struct BTNode* leftchild;
	struct BTNode* rightchild;
	ElemType data;
}BTNode, *BinaryTree;

购买节点：

BTNode* BuyNode(ElemType val){
	BTNode* s = (BTNode*)malloc(sizeof(BTNode));
	if(s == NULL) exit(EXIT_FAILURE);
	s->data = val;
	s->leftchild = NULL;
	s->rightchild = NULL;
	return s;
}

释放函数：

void FreeNode(BTNode* p){
	free(p);
}

二叉树节点个数：
可以用递归找左子树与右子树个数，再加上根节点

int GetSize(BTNode* p){
	if(p == NULL) return 0;
	return GetSize(p->leftchild) + 
			GetSize(p->rightchild) + 1;
}

二叉树高度：
与查询节点个数相似，递归查找左子树右子树的高度最大值
需要自己写一个找最大值的函数

int Max(int a,int b){
	return a>b?a:b;
}
int GetDepth(BTNode* p){
	if(p == NULL) return 0;
	return Max(GetDepth(p->leftchild),GetDepth(p->rightchild)) + 1;
}

创建二叉树：
手动输入字符串创建二叉树，#表示NULL
ch不等于’#'就赋值给s，递归赋值左子树右子树

BTNode* CreateBinatyTree(){
	ElemType ch;
	BTNode* s=NULL;
	scanf("%c",&ch);
	if(ch!='#'){
		s = BuyNode(ch);
		s->leftchild = CreateBinaryTree();
		s->rightchild = CreateBinaryTree();
	}
	return s;
}

测试用例
这里使用了前序遍历测试

创建二叉树2:
不输入，在主函数中定义p(这里是老师第一次摩擦我，指针花活绕死我了，用的应该是c++中的知识，clion不让俩语言一块用)

BTNode* CreateBinaryTree(const char** p){
	BTNode* s=NULL;
	if(p!=NULL && *p!=NULL && **p!='#'){
		s= BuyNode(**p);
		s->leftchild = CreateBinaryTree(&++*p);
		s->rightchild = CreateBinaryTree(&++*p);
	}
	return s;
}

以上两种方法都是告诉了NULL，下面为只有data创建二叉树

利用前序中序排序字符串创建二叉树（PI）：
前序的第一个字符为根节点，在中序中，根节点左边的全是左子树，右边的全为右子树。利用这一逻辑创建二叉树。
首先要找到根节点的下标位置

int FindIs(const char* is,char ps,int n){
	assert(is!=NULL);
	for(int i=0;i<n;++i){
		if(ps = is[i]) return i;
	}
	return -1;
}//is为中序排序，ps为根节点字符，n为字符串长度，
//用i返回根节点在is中的下标

BTNode* CreatePI(const char* ps,const char* is,int n){
	BTNode* s = NULL;
	if(n>0){
		s = BuyNode(ps[0]);//前序第一位为根节点
		int pos = FindIs(is,ps[0],n);//找is中根节点的下标
		if(-1 == pos) exit(EXIT_FAILURE);
		//递归写出左子树与右子树
		//左子树前序排序从第二个节点开始pos个，中序从0开始pos个
		s->leftchild = CreatePI(ps+1,is,pos);
		//右子树前序排序从pos+1节点开始n-pos-1个
		//    	中序排序从pos+1节点开始n-pos-1个
		s->rightchild = CreatPI(ps+pos+1,is+pos+1,n-pos-1);
	}
	return s;
}
BTNode* CreateBinaryTreePI(const char* ps,const char* is){
	assert(ps!=NULL && is!=null);
	int n = strlen(ps);
	return CreatePI(ps,is,n);
}

利用后序遍历检验，运行成功。
在这里插入图片描述
利用中序后序排序字符串创建二叉树（IL）
后序排序最后一个字符为根节点，在中序排序中找到根节点的下标pos，左子树的中序排序为0～pos，后序排序为0～pos
右子树的中序排序为pos+1 ～ n-pos-1，后序排序为pos ～n-pos-1

BTNode* CreateIL(const char* is,const char* ls,int n){
	BTNode* s=NULL;
	if(n>0){
		s = BuyNode(ls[n-1]);
		int pos = FindIs(is,ls[n-1],n);
		if(-1 == NULL) exit(EXIT_FAILURE);
		s->leftchild = CreateIL(is,ps,pos);
		s->rightchild = CreateIL(is+pos+1,ls+pos,n-pos-1);
	}
	return s;
}
BTNode* CreateBinaryTreeIL(const char* is,const char* ls){
	assert(is!=NULL&&ls!=NULL);
	int n=strlen(is);
	return CreateIL(is,ls,n);
}

利用前序遍历检验
在这里插入图片描述

前中后序，层次遍历

递归遍历比较简单，根据逻辑写代码就行。

前序遍历：
使用递归实现，逻辑即为“根左右”，访问到根的时候就打印，然后递归遍历左子树，右子树

void PreOrder(BTNode* p){
	if(p != NULL){
		printf("%c",p->data);
		PreOrder(p->leftchild);
		PreOrder(p->rightchild);
	}	
}

中序遍历：
逻辑为“左根右”，到根的时候打印，否则递归

void InOrder(BTNode* p){
	if(p != NULL){
		InOrder(p->leftchild);
		printf("%c",p->data);
		InOrder(p->rightchild);
	}
}

后序遍历：
逻辑为“左右根”，到根的时候打印，否则递归

void PastOrder(BTNode* p){
	if(p!=NULL){
		PastOrder(p->leftchild);
		PastOrder(p->rightchild);
		printf("%c",p->data);
	}
}

层次遍历较为复杂，老师用到了队列
逻辑顺序为：
1.将根节点先入队。
2.队头出队打印，并且访问左右节点，非空便依次入队

void NiceLevelOrder(BTNode* ptr){
	if(ptr == NULL) return;
	std::queue<BTNode*> qu;
    qu.push(ptr);
    while (!qu.empty())//队列不为空就循环
    {
        ptr = qu.front(); qu.pop();//队头出列并打印
        printf("%c ", ptr->data);
        if (ptr->leftchild != nullptr)
        {//左子树不为空就入队
            qu.push(ptr->leftchild);
        }
        if (ptr->rightchild != nullptr)
        {//右子树不为空就入队
            qu.push(ptr->rightchild);
        }
    }
    printf("\n");
}

非递归遍历

这里用到了栈
非递归中序遍历
当树不为空时，向栈中传入数据，树指向左子树。当树空时，即为没有了左子树，出栈并且打印，此时打印的就是最下面的左子树。然后将树ptr赋值为右子树。逻辑便是左根右。

void NiceInOrder(BTNode* ptr){//非递归中序遍历
    if(ptr == NULL) return;
    LinkStack mys;
    InitStack(&mys);
    while(ptr!=NULL || !StackEmpty(&mys)) {
        while (ptr != NULL) {
            Push(&mys, ptr->data);//左子树不为空就入栈
            ptr = ptr->leftchild;//往左子树走
        }
        Pop(&mys, &ptr);//左子树为空时出栈
        printf("%c", ptr->data);//出栈并打印
        ptr = ptr->rightchild;//根有右子树就赋值，没有右子树就下一个循环
    }
    DestroyStack(&mys);
}

非递归后序遍历
与中序遍历不同，中序遍历一直往左走就可以了，但是后序遍历需要考虑右子树，这里用到了tag标记，还不是很明白，再去看看回放。

void StkNicePastOrder(BTNode* ptr)
{
    if (ptr == NULL) return;
    BTNode* tag = NULL;
    LinkStack mys;
    InitStack(&mys);
    SElemType e, x = { ptr,0 };
    Push(&mys, x);
    while (!StackEmpty(&mys))
    {
        Pop(&mys, &e);
        if (++e.popnum == 3)
        {
            printf("%c ", e.pnode->data);
        }
        else
        {
            Push(&mys, e);
            if (e.popnum == 1 && e.pnode->leftchild != nullptr)
            {
                SElemType left = { e.pnode->leftchild,0 };
                Push(&mys, left);
            }
            else if (e.popnum == 2 && e.pnode->rightchild != nullptr)
            {
                SElemType right = { e.pnode->rightchild , 0 };
                Push(&mys, right);
            }
        }
    }
    printf("\n");
    DestroyStack(&mys);
}

查询

二叉树查找某一个值
这个较为简单，利用递归，根节点不对就去找左子树，左子树为空就找右子树

BTNode* FindValue(BTNode* ptr,elemType val){
	if(ptr == NULL || ptr->data == val) return ptr;
	else {
		BTNode* p = FindValue(ptr->leftchild,val);
		if(p == NULL){
			p=FindValue(ptr->rightchild,val);
		}else{
			return p;
		}
	}
}

二叉树找双亲
与查询值相似，递归即可

BTNode* FindParent(BTNode* ptr,elemType child){
	if(ptr == NULL || ptr->leftchild == child || ptr->rightchild == child){
		return ptr;
	}else{
		BTNode* p = FindParent(ptr->leftchild,child);
		if(p == NULL){
			p = FindParent(ptr->rightchild,child);
		}else return p;
	}
}

二叉树查找最近公共祖先

二叉搜索树(BST树)

二叉搜索树的定义：
左子树都小于根节点的值
右子树都大于根节点的值

这一性质使BST树的查询速度要由于链表查询，要么比val大要么比val小
但当数组极端情况下，也就是数组有序时，二叉搜索树就退化成一个仅有右子树或左子树的树，类似于链表。后文将讲述优化方法。
BST树的定义
与二叉树定义相同，这里的数据类型改为int，加入双亲节点parent

typedef int ElemType;
typedef struct BstNode //BinarySortTreeNode
{
    struct BstNode* leftchild;
    struct BstNode* parent;
    struct BstNode* rightchild;
    ElemType data;
}BstNode, * PBstNode;

typedef struct
{
    BstNode* root;
    int cursize;
}BinarySortTree;

BstNode* Buynode(ElemType val, BstNode* Parg = nullptr,
    BstNode* Larg = nullptr, BstNode* Rarg = nullptr)；//这里不再赘述
void Freenode(BstNode* p)；
void InitBSTree(BinarySortTree * ptree)；
void DestroyBSTree(BinarySortTree* ptree);；

BST树查询
利用递归，val的值大于当前节点或小于当前节点，或者就等于当前节点的值。类似于中序遍历。

BstNode* SearchValue(BstNode* ptr, ElemType val)
{
    BstNode* p = nullptr;
    if (nullptr == ptr || val == ptr->data)
    {
        p = ptr;
    }
    else if (val < ptr->data)
    {
        p = SearchValue(ptr->leftchild, val);
    }
    else
    {
        p = SearchValue(ptr->rightchild, val);
    }
    return p;//用指针p返回
}

插入节点
1.如果树为空，就直接插入，cursize+1.
2.找到应该插入的位置，左子树或者右子树。
3.找到应插入的节点后，判断应该插在左边或者右边

bool  Insert(BinarySortTree * proot, ElemType val)
{
    if (nullptr == *proot)
    {
        *proot = Buynode(val);
        return true;
    }//二叉树为空直接插入
    BstNode* pa = nullptr;//定义一个节点标记应该插入的节点
    BstNode* p = *proot;
    while (p != nullptr && p->data != val)
    {
        pa = p;
        p = val < p->data ? p->leftchild : p->rightchild;
    }//val小就往左走，大就往右走。
    //当p为空时，也就是查询到了应插入的位置，并且pa标记了
    if (p != nullptr) return false;//p不为空表示没有地方可以插入。
    p = Buynode(val, pa);//在pa处购买节点，值为val
    if (p->data < pa->data)
    {
        pa->leftchild = p;
    }//val小于pa->data就插在左边
    else
    {
        pa->rightchild = p;
    }//val大于pa->data就插在右边
    return true;
}

删除节点
1.如果树为空或者找不到要删除的值，就返回false
2.

在这里插入代码片

AVL树

前面讲过，如果二叉搜索树遇到了极端情况，也就是数组本身就有序，做成BST树就会退化成一个链表，查询时间大大增加。因此需要优化，让我们制作BST树时，能让数值均匀的分布在二叉树的左右。
数据结构｜平衡二叉搜索树(AVL树)
退化

红黑树（RBTree）

未完待续，持续更新

voldlad
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
合工大数据结构实验 二叉树
04-14
本实验的主题是“二叉树”，这是数据结构中一个基础且重要的概念。二叉树是一种非线性的数据结构，由节点（或称为顶点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验旨在帮助学生深入理解...
为什么最难不过二叉树的算法出现在面试题中都会被应聘者抱怨？
varyall的专栏
12-21 2637
因为他们觉得反正招进来之后我也用不上二叉树，你们谁写业务代码的时候用上二叉树了？所以我不会就不会呗。这其实就是“高等数学有啥用，又不能用来买菜”的进化版本。 的确很少有写业务代码的时候会直接用上二叉树。但是真的没有吗？XML/DOM是什么？是不是一棵树？为什么DOM可以和XML一一对应？因为XML序列化就是树的遍历的结果。能和XML对应，也就能跟JSON对应，因为两者
二叉树难理解？不妨来看看这个（二叉树逐步刨析 一）
热门推荐
weixin_64067830的博客
04-25 5万+
​         大家好，这里是小张，上次已经把c++中类的继承（大家可以进我空间看我的上面的几篇博客）说完了，今天我们就开始来更新二叉树系列，希望能给大家带来帮助，废话不多说，我们现在就开始。         在大学中常常流传着这样一段话：大学里有一棵树，上面挂着好多人，这棵树叫做高数，再继续往前走，又有一棵树上面挂着好多人，这棵树就叫做二叉树
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
数据结构-二叉树基础.pdf
04-15
数据结构 -二叉树基础.pdf
数据结构-二叉树的基本操作
09-26
二叉树相关的完整代码
6、Redis系统-数据结构-06-跳表
qq_29434541的博客
07-07 341
在 Redis 中，跳表通过高效的多级链表结构，实现了有序集合的快速插入、删除和查询操作，适用于需要有序数据存储的场景。跳表通过多级链表的形式实现，每一级链表都跳过一些元素，从而在查询时能够快速跳过不必要的元素。跳表的每个节点包含一个或多个前进指针，这些前进指针指向不同级别的节点，使得跳表具有高效的查询性能。删除节点时，通过查找操作确定节点位置，然后在每一级链表中移除该节点，并调整相关节点的前进指针和跨度。插入新节点时，首先确定新节点的级别，然后在每一级链表中找到插入位置，将新节点插入到相应的位置。
数据结构第14节 加权图
hummhumm的专栏
07-07 851
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
数据结构（期末）
qq_53573029的博客
07-04 824
栈：受约束的线性表，只允许栈顶元素入栈和出栈对栈来说，表尾端称为栈顶，表头端称为栈底，不含元素的空表称为空栈先进后出，后进先出。
数据结构之栈
qq_74336191的博客
07-07 920
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除操作。进入数据插入和删除操作的一端称为栈顶，另一端称为栈底。
数据结构第07节：队列
hummhumm的专栏
07-04 427
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构之链表
最新发布
2301_80772499的博客
07-07 301
链表的结构，是否带头，是否循环，是否双向六中结构讲解，以及链表的用途.
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 552
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
6、Redis系统-数据结构-04-Hash
qq_29434541的博客
07-07 672
table：指向哈希表节点指针数组的指针。size：哈希表的大小，即哈希表数组的长度。sizemask：哈希表大小掩码，用于计算键的索引值。used：哈希表中已使用的节点数量。rehashidx：rehash 的索引，表示当前进行到哪个位置，-1 表示没有进行 rehash。type：指向哈希表类型特定函数的指针，用于实现不同类型的哈希表。privdata：指向私有数据的指针，可以用于存储与哈希表相关的额外信息。
【高阶数据结构】B-数、B+树、B*树的原理
稻草人敲代码的博客
07-04 771
B树：有序数组+平衡多叉树B+树：有序数组链表+平衡多叉树B*树：一棵更丰满的，空间利用率更高的B+树。
数据结构--顺序表
LH__1314的博客
06-30 4218
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
数据结构第08小节：双端队列
hummhumm的专栏
07-04 903
双端队列（deque，double-ended queue）是一种具有队列和栈特性的数据结构，允许在其两端进行插入和删除操作。在Java中，接口就是双端队列的实现，而ArrayDeque和LinkedList是其中的具体实现类。下面是一个使用ArrayDeque实现的双端队列的例子，我们将使用它来管理一个在线购物车系统中的商品列表。用户可以从任何一端（前面或后面）添加或移除商品。
数据结构二叉树优选ppt资料.ppt
12-01
"数据结构二叉树优选ppt资料.ppt" 这份资料主要涵盖了数据结构中的核心概念——二叉树。二叉树是数据结构中的一个重要组成部分，它是一种特殊的树形结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值