【考研-数据结构】树和二叉树

最新推荐文章于 2022-11-08 20:46:14 发布
最新推荐文章于 2022-11-08 20:46:14 发布
阅读量345 收藏 1
点赞数
分类专栏： 考研-数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Manner11/article/details/113834536
版权
这篇博客详细介绍了二叉树的相关操作，包括初始化、插入节点、先序、中序、后序遍历的递归与非递归实现，以及层次遍历。此外，还讲解了线索二叉树的概念，如何通过线索化实现快速查找前驱和后继节点。最后，讨论了二叉排序树的搜索、插入操作，并提到了平衡二叉树和哈夫曼树等高级主题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【考研-数据结构】树和二叉树

1.二叉树

#include <iostream>
#define MaxSize 20
using namespace std;
typedef struct BiTNode{
    int data;
    struct BiTNode *lchild,*rchild;
    //struct BiTNode* parent;
}BiTNode,*BiTree;


//链式队列
typedef struct LinkNode {
    BiTNode* data;
    LinkNode* next;
}LinkNode;
typedef struct {
    LinkNode* rear, * front;
}LinkQueue;
//链式队列


//初始化并建立根节点
void Init_root(BiTree& root,int e){
    //定义空树
    BiTree root = NULL;
    root = new BiTNode();
    root->data = e;
    root->lchild = nullptr;
    root->rchild = nullptr;
}
//插入第一个新节点
void Insert_Node(BiTree& root,int e){
    BiTNode* p= new BiTNode();
    p->data = e;
    p->lchild = nullptr;
    p->rchild = p;
}

//访问结点
void visit(BiTree T){
    if(T!=nullptr){
        cout<<T->data<<endl;
    }
}

//先序遍历(递归算法)
void PreOrder(BiTree T){
    if(T!=nullptr){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

//先序遍历(非递归算法)(后加的，函数名可能对不上)
void PreOrder02(BiTree T){
	InitStack(S);
	BiTree p = T;
	while(p||IsEmpty(S)){
		if(p){
			visit(p);
			Push(S,p);
			p = p->lchild;
		}else{
			Pop(S,p);
			p = p->rchild;
		}
	}
}

//中序遍历
void InOrder(BiTree T){
    if(T!=nullptr){
        PreOrder(T->lchild);
        visit(T);
        PreOrder(T->rchild);
    }
}
 
//中序遍历(非递归算法)(后加的，函数名可能对不上)
void InOrder02(BiTree T){
	InitStack(S);
	BiTree p = T;
	while(p||IsEmpty(S)){
		if(p){
			Push(S,p);
			p = p->lchild;
		}else{
			Pop(S,p);
			visit(p);
			p = p->rchild;
		}
	}
}

//后序遍历
void PostOrder(BiTree T){
    if(T!=nullptr){
        PreOrder(T->lchild);
        PreOrder(T->rchild);
        visit(T);
    }
}

//求树的深度
int treeDepth(BiTree T){
    if(T == nullptr){
        return 0;
    }else{
        int l = treeDepth(T->lchild);
        int r = treeDepth(T->rchild);
        return l>r?l+1:r+1;
    }
}


//********队列操作
//初始化
void InitQueue(LinkQueue& Q) {
    Q.rear = Q.front = new LinkNode();
    Q.front->next = nullptr;
}

//判断队列是否为空
bool isEmpty(LinkQueue Q) {
    if (Q.front == Q.rear) {
        return true;
    }
    else {
        return false;
    }
}

//入队
void EnQueue(LinkQueue& Q, BiTNode *e) {
    LinkNode* temp = new LinkNode();
    temp->data = e;
    temp->next = nullptr;
    Q.rear->next = temp;
    Q.rear = temp;
}

//出队
bool DeQueue(LinkQueue& Q, BiTNode*& x) {
    if (Q.front == Q.rear) return false;
    LinkNode* temp = Q.front->next;
    x = temp->data;
    Q.front->next = Q.front->next->next;
    if (Q.front->next == nullptr) {
        Q.rear = Q.front;
    }
    delete temp;
    return true;
}
//********队列操作




//层次遍历:初始化一个辅助队列，如果队列非空则队头出一个结点
//然后将弹出的结点的左右结点按顺序入队
void LevelOrder(BiTree T){
    LinkQueue Q;
    InitQueue(Q);                 //初始化辅助队列
    BiTree p;
    EnQueue(Q,T);           //根节点入队
    while(!isEmpty(Q)){           //队列不空的时候循环
        DeQueue(Q,p);       //队头结点出队
        visit(p);                 //访问处对接点
        if(p->lchild!=nullptr){
            EnQueue(Q,p->lchild); //左节点入队
        }
        if(p->rchild!=nullptr){
            EnQueue(Q,p->rchild); //右节点入队
        }
    }
}

//根据遍历创建二叉树(中序加其余任意一种)

int main() {



    return 0;
}

2.线索二叉树

#include<iostream>
using namespace std;
//线索二叉树
//作用：方便从一个指定结点出发，找到其前驱和后继节点，方便遍历
typedef struct ThreadNode{
    int data;
    struct ThreadNode *lchild,*rchild;
    int ltag,rtag;
    //左右线索标志位 
    //(tag=0的时候指向左右孩子,tag=1的时候指向线索,表示指向前驱和后继
}ThreadNode,*ThreadTree;

//普通二叉树
typedef struct BiTNode{
    int data;
    struct BiTNode *lchild,*rchild;
    //struct BiTNode* parent;
}BiTNode,*BiTree;


//中序线索化01(笨方法)
void InOrder(BiTree T){
    if(T!=nullptr){
        InOrder(T->lchild);
        visit(T);
        InOrder(T->rchild);
    }
}
BiTNode* p;
BiTNode* pre = nullptr;
BiTNode* final = nullptr;
void visit(BiTNode *q){
    if(q == p){
        final = pre;
    }else{
        pre = q;
    }
}
//中序线索化02(最后一个结点要特殊处理)
ThreadNode* pre02 = nullptr;
void CreateInThread(ThreadTree T){
    pre02 = nullptr;
    if(T!=nullptr){
        InThread(T);
        //处理最后一个结点
        if(pre02->rchild == nullptr){
            pre02->rtag = 1;
        }
    }
}
void InThread(ThreadTree T){
    if(T!=nullptr){
        InThread(T->lchild);
        visit02(T);
        InThread(T->rchild);
    }
}
void visit02(ThreadNode *q){
    if(q->lchild == nullptr){
        q->lchild = pre02;
        q->ltag = 1;
    }
    if(pre!=nullptr&&pre->rchild == nullptr){
        pre02->rchild = q;
        pre02->rtag = 1;
    }
    pre02 = q;
}


//前序线索化
ThreadNode* pre03 = nullptr;
void CreatePreThread(ThreadTree T){
    pre03 = nullptr;
    if(T!=nullptr){
        InThread(T);
        //处理最后一个结点
        if(pre03->rchild == nullptr){
            pre03->rtag = 1;
        }
    }
}
void PreThread(ThreadTree T){
    if(T != nullptr){
        visit03(T);
        if(T->ltag == 0){
            PreThread(T->lchild);
        }
        PreThread(T->rchild);
    }
}
void visit03(ThreadNode* q){
    if(q->lchild == nullptr){
        q->lchild = pre03;
        q->ltag = 1;
    }
    if(pre03!=nullptr&&pre03->rchild == nullptr){
        pre03->rchild = q;
        pre03->rtag = 1;
    }
    pre03 = q;
}


//后序线索化
ThreadNode* pre04 = nullptr;
void CreatePostThread(ThreadTree T){
    pre04 = nullptr;
    if(T!=nullptr){
        InThread(T);
        //处理最后一个结点
        if(pre04->rchild == nullptr){
            pre04->rtag = 1;
        }
    }
}
void PostThread(ThreadTree T){
    if(T != nullptr){
        PostThread(T->lchild);
        PostThread(T->rchild);
        visit03(T);
    }
}
void visit03(ThreadNode* q){
    if(q->lchild == nullptr){
        q->lchild = pre04;
        q->ltag = 1;
    }
    if(pre04!=nullptr&&pre04->rchild == nullptr){
        pre04->rchild = q;
        pre04->rtag = 1;
    }
    pre04 = q;
}


//中序线索二叉树找中序后继

//找到以p为跟的子树中,第一个被中序遍历的结点
ThreadNode*Firstnode(ThreadNode*p){
    //循环找到最左下结点(不一定是叶子结点)
    while(p->ltag == 0) p = p->lchild;
    return p;
}
//在中序线索二叉树中找到结点p的后继节点
ThreadNode*Nextnode(ThreadNode*p){
    //右子树中最左下结点
    if(p->rtag == 0) return Firstnode(p->rchild);
    //p->rtag == 1,p->rchild就是后继
    else return p->rchild;  
}
//对中序线索二叉树进行中序遍历(利用线索实现的非递归算法)
void InOrder(ThreadNode* T){
    for(ThreadNode* p = Firstnode(T);p!=nullptr;p = Nextnode(p)){
        visit_zb(p);
    }
}
void visit_zb(ThreadNode* p){
    if(p!=nullptr){
        cout<<p->data<<endl;
    }
}


//中序线索二叉树找中序前驱

//找到以p为跟的子树中，最后一个被中序遍历的结点
ThreadNode*Lastnode(ThreadNode*p){
    //循环找到最右下结点(不一定是叶子结点)
    while(p->rtag == 0) p = p->rchild;
    return p;
}
//在中序线索二叉树中找到结点p的前驱结点
ThreadNode *Prenode(ThreadNode*p){
    //左子树中最右下结点
    if(p->ltag == 0) return Lastnode(p->lchild);
    //p->ltag == 1,p->lchild就是前驱结点
    else return p->lchild;
}
//对中序线索二叉树进行逆向中序遍历
void ReInorder(ThreadNode*T){
    for(ThreadNode *p = Lastnode(T);p!=nullptr;p = Prenode(p)){
        visit_zb(p);
    }
}

//先序线索二叉树中找先序后继
//1.p->rtag == 1,next = p->rchild
//2.p->rtag == 0，若p有左孩子，则先序后继为左孩子，
//若p没有左孩子，则先序后继为右孩子

//先序线索二叉树找先序前驱
//1.p->ltag == 1,pre = p->lchild
//2.p->ltag == 0
//(找不到，除非用土方法，再次遍历二叉树，见上,也可用三叉链表，加一个父亲结点)


//后序线索二叉树找后续先驱
//1.p->ltag == 1.pre = p->lchild
//2.p->ltag == 0.若p有右孩子，则前驱为右孩子
//若p没有右孩子，则前驱为左孩子

//后续线索二叉树找找后续后继
//1.p->rtag == 1.next = p->rchild
//2.p->rtag == 0,
//(找不到，除非用土方法，再次遍历二叉树，见上，也可用三叉链表，加一个父亲结点)


int main() {

    return 0;
}

3.二叉排序树和森林

//树和森林
#include<iostream>
using namespace std;

//树的先根遍历和对应二叉树的先序遍历相同(深度优先遍历)
//树的后根遍历和对应二叉树的中序遍历相同(深度优先遍历)
//树的层次遍历与二叉树相同(广度优先遍历)

//森林的先序遍历和对应二叉树的先根遍历相同
//森林的中序遍历等同于依次对每个树进行后根遍历(对应二叉树的中序遍历)


//二叉排序树
//左节点<根结点值<右结点值
typedef struct BSNode{
    int key;
    struct BSNode *lchild,*rchild;
}BSTNode,*BSTree; 
//1.搜索
//非递归
BSTNode*BST_Search(BSTree T,int key){
    while(T!=nullptr&&T->key!=key){
        if(key>T->key) T = T->rchild;
        else T = T->lchild;
    }
    return T;
}
//递归实现
BSTNode*BST_Search02(BSTree T,int key){
    if(T == nullptr) return nullptr;
    if(key == T->key) return T;
    else if(key<T->key) return BST_Search02(T->lchild,key);
    else return BST_Search02(T->rchild,key);
}

//2.插入
//递归实现
int BST_Insert(BSTree &T,int k){
    if(T == nullptr){
        T = new BSTNode();
        T->key = k;
        T->lchild = T->rchild = nullptr;
        return 1;  //返回1,插入成功
    }
    else if(k == T->key) 
        return 0;
    else if(k < T->key){
        return BST_Insert(T->lchild,k);
    }
    else if(k > T->key){
        return BST_Insert(T->rchild,k);
    }
    return 0;
}
//非递归实现(需要改动)
int BST_Insert02(BSTree &T,int k){
    while(T!=nullptr){
        if(k<T->key){
            T = T->lchild;
        }else if(k>T->key){
            T = T->rchild;
        }else if(k == T->key){
            return 0;
        }
    }
    T = new BSTNode();
    T->key = k;
    T->lchild = T->rchild = nullptr;
    return 1;
}

//二叉排序树的构造
void Create_BST(BSTree &T,int str[],int n){
    T = nullptr;
    int i = 0;
    while(i<n){
        BST_Insert(T,str[i]);
        i++;
    }
}

//二叉排序树的删除(删除之后，使用直接前驱或者直接后继来代替)
//1.被删节点是叶子结点，直接删除
//2.被删节点只有左子树或者只有右子树，用其子树定顶替位置
//3.被删节点有左子树和右子树：
//  (1)可用其后继节点顶替，再删除后继节点
//  (2)可用其前驱节点顶替，再删除前驱节点
//  (3)前驱：左子树最右下角的结点
//  (4)后继：右子树中最左下角的结点


//平衡二叉树(查找效率O(log2(n)))
//左节点进行右旋转
//右节点进行左旋转

//哈夫曼树(最优二叉树)






int main() {
    BSTree T;
    //T = new BSTNode();
    //T->lchild = nullptr;
    //T->rchild = nullptr;
    //T->key = 1;
    int str[] = {2,3};
    Create_BST(T,str,2);
    cout<<T->key<<endl;
    //cout<<T->rchild->key<<endl;
    //cout<<T->rchild->rchild->key<<endl;
    /*
    cout<<BST_Insert(T,2)<<endl;
    cout<<BST_Insert(T,1)<<endl;
    cout<<BST_Insert(T,3)<<endl;
    cout<<"---"<<endl;
    cout<<T->key<<endl;
    cout<<T->lchild->key<<endl;
    cout<<T->rchild->key<<endl;
    */

    return 0;
}
数据结构-树与二叉树-思维导图+小结
学习记录
11-26 2532
数据结构-第五章-树与二叉树-思维导图+小结
考研系列-数据结构第五章：树与二叉树（上）
最新发布
Nelson_hehe的博客
06-19 800
本文是408考研付费专栏系列-数据结构树与二叉树章节（上半部分），本文详细地总结了树的基本知识点，对树的概念、常见的术语、常用的树的性质进行了总结；对特殊的树结构-二叉树的种类、性质、存储结构、遍历操作的手算和代码实现、线索化进行了总结归纳，并对常见错题进行了整理。
考研数据结构-二叉树
weixin_30561425的博客
07-30 198
本篇不想写什么了，后续想到什么再更上吧。 注：本代码二叉树的构建是按照二叉排序树来构建的。后续的测试等都用到此二叉树。 代码大部分来源于《数据结构考研复习指导》，即王道单科。 层次遍历： 求某一层的结点个数，树的高度，每一层结点个数，树的最大宽度 中序遍历： 判断是否二叉排序树 后序遍历： 判断是否平衡二叉树，树的高度， ...
【数据结构】【考研】树与二叉树
weixin_44048403的博客
10-22 1536
二叉树（binary tree）是有限的节点集合，这个集合或者为空，或者由一个根节点和两棵互不相交的称为左子树和右子树的二叉树组成。
【考研】数据结构之平衡二叉树考点
qq_34438969的博客
07-28 1613
以下有关平衡二叉树的考点内容，源于对《数据结构（C语言版）第2版》及王道讲解的整理和总结。重要考点插入新结点后，如何调整“不平衡”问题。
数据结构：树与二叉树（考研专业知识汇总）
iris的博客
07-26 670
一、 树与二叉树的关系 二叉树不是树的一种特殊结构，他们是不同的树形结构，是不同的数据结构，不要将其搞混。 二、树的基本概念 1、树的定义（其逻辑结构） 简单来说 1 除了根结点外，每个节点都有可能有很多的直接后继。 2每个节点都有且只有一个直接前驱。 2、 基本术语 在这里，为了避免过多文字的杂述，我通过一个树的例子，在这棵树上，将树中的基本概念基本标出。 3、树的性质 1 树的节点树=所有节点的度数+1（根结点） 2 度为m的树中第i层至多有m^(I-1)个节点（i>=1） 三、二叉树的概念 1
考研复习之二叉树
朱发财的博客
07-02 286
怎么硕呢？ 之前学的二叉树基本上忘得差不多了 今天大概复习了一下，今天结合考研的书（王道）重新写了一遍。 包括：递归前中后序，非递归前中后序，层序遍历以及二叉树的构建。 参考了书中的代码，所以很接近考研的思路和习惯，废话不多说了，上代码。 #include <iostream> #include <vector> #include <string> #include <algorithm> #include <queue> #inclu
王道考研-数据结构笔记
09-16
树是一种非线性的数据结构，包括二叉树、平衡树（如AVL树、红黑树）、B树、B+树等。它们常用于查找、排序、文件系统等领域。例如，二叉搜索树能够快速查找数据，平衡树则保证了查找效率的稳定。图是更复杂的一种数据...
2022王道考研-数据结构笔记.zip
06-16
“王道考研-数据结构笔记”这份资料很可能是涵盖了这些基础知识以及相关的算法和问题解决技巧，适合准备考研的学生以及希望提升编程技能的初学者。通过学习这些笔记，你可以深入了解数据结构的概念，学习如何根据...
数据结构考研第五章——树与二叉树（内含动图）
m0_46638350的博客
11-08 1436
数据结构、考研、第五章、树与二叉树、内含动图、总结、笔记
考研算法(四) 二叉树
sssssssssnake的博客
09-16 358
前序遍历有个口诀即头左右，我们第一次访问的结点就是当前子树的头结点，所以直接压入栈即可。中序遍历的顺序为左头右，我们先保证最左的结点先被处理，只需将从头结点到最左的结点全部压入即可。这里设置最近访问结点的原因在于我们不能判断这是从头结点的最左结点返回的还是从当前头结点的右子树的头结点的最左结点返回的。中序遍历的顺序为左头右，我们先保证最左的结点先被处理，只需将从头结点到最左的结点全部压入即可。我们发现栈里的最左结点的下面一个结点正好是它的头结点，将它弹出栈，然后处理右子树的结点就可以了。
考研复习之树-1
weixin_43411341的博客
07-12 379
树与二叉树重要的定义和概念树的基本术语树的存储结构考点：二叉树满二叉树完全二叉树简单的结点数的计算二叉树的存储结构二叉树的遍历算法很重要生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 重要的定义和概念 树的基本术语 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几
考研数据结构——(树)
Seven597的博客
06-02 612
考研数据结构——(树与二叉树一、 树的基本概念1.1 树的 性质 一、 树的基本概念 1.1 树的 性质
【考研】常考的二叉树相关算法总结（详细全面）
qq_34438969的博客
09-28 3486
本文内容主要针对考研常考的二叉树相关算法，包括但不限于对普通二叉树的构造、查找、插入元素、（先序、中序、后序、层序）遍历，并含递归和非递归方式等的算法、二叉排序树的构造、查找和插入等等算法。因为考研中用二叉链表的存储结构较多，所以二叉树用的存储结构都是二叉链表。如果有错误的地方，请留言一起探讨。（后期会继续补充有关二叉树的算法）【考研】数据结构——线索二叉树_住在阳光的心里的博客-优快云博客【考研】《数据结构》知识点总结.pdf_其它文档类资源-优快云下载。
考研数据结构之树（6.1）——二叉树的遍历算法（C表示）
二木成林
06-04 888
二叉树的主要遍历方式有先序遍历、中序遍历、后序遍历和层次遍历。 1.先序遍历 先序遍历的操作过程如下： 如果二叉树为空树，则什么都不做；否则： （1）访问根节点 （2）先序遍历左子树 （3）先序遍历右子树 对应算法代码如下： /* 先序遍历 */ /* *p指的是二叉树的根节点 */ void preOrder(BTNode *p) { if(p!=NULL) { printf("%c",p->data);// 打印树结点的数据 preOrder(p->lchild
10. 王道考研-树与二叉树
衍射的博客
06-24 403
文章目录一、树的概念二、树的性质三、二叉树3.1 特殊二叉树3.2 二叉树的性质 一、树的概念 树是一种逻辑结构，是n(n>=0)个节点的有限集合，n=0时，称为空树，而任意的非空树满足： 1） 有且仅有一个特定的称为根的节点 2) 当n> 1时，其余结点可分为m (m>0)个互不相交的有限集合，其中每一个集合本身又是一棵树，称为根结点的子树。 基本术语： 森林是m（m>=0）棵互不相交的树的集合 二、树的性质 树的结点数 = 所有节点的度数+1 = 边数 + 1 度
数据结构（考研）第五章 树与二叉树
bestkasscn的博客
05-13 361
第五章 树与二叉树 5.1 树的基本概念 5.1.1 树的定义 树是n个结点的有限集。当n=0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个称为根的结点 当n>1时，其余结点可分为m个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树 树的定义是递归的，树本身也是一种递归的数据结构。其作为一种逻辑结构，同时也是一种分层结构。树适合表示具有层次结构的数据。 5.1.2 基本术语 度。树中一个结点的孩子个数称为该结点的度，树中结点的最大度数称为树的度。 路径和路径长度。树中两个结
考研复习整理之——二叉树层次遍历
qq_38758395的博客
09-19 420
考研复习整理之——二叉树层次遍历 1.思路 层次遍历，是指由左至右，由上之下，由层遍历一棵树。在层次遍历中，用到的不是递归，而是循环，通过建立一个队列，每次循环将所需遍历的结点出队并访问，然后再将改结点的子节点按由左至右的顺序入队，反复循环直至检测到队列为空，即说明已经遍历完毕。 注：这个队列应该存储的是结点的指针而不是结点，原因是因为树已经构建好了，如果存储结点的话会复制一份到队列中，浪费内存不...
大话西游之王道考研数据结构第七讲---树、森林以及应用
PoorLemon的博客
08-03 541
                                        第六讲--二叉树的遍历和线索化二叉树 复习 线索化二叉树的目的是什么？ n个结点的二叉树的链式表示中，空链域有多少个？ ltag和rtag分别为多少时候，代表什么？ 为什么后续线索化二叉树中，某些结点有可能找不到其后继结点？ 一、树的san种存储结构 这个就比较easy了，我们知道二叉树的存储结构里面就是有...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值