树结构 复习

已于 2023-02-07 09:59:12 修改
阅读量506 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构
于 2023-02-06 11:28:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JYHZZ/article/details/128896200
版权

1.树的根节点没有前驱结点，除根节点以外的其他结点只有一个前驱结点。

2.树中所有结点有0或多个后继结点。

3.结点的度：结点所拥有的的子树个数。

   树的度：树中各节点的最大度数。

4.分支结点（非终端结点）：度不为0的结点。也就是说，除了叶节点的都是非终端节点。

5.根节点层数为1。

6.二叉树有5种基本形态。（空树，只有根节点，有左子树，有右子树，有左右子树）

7.满二叉树与完全二叉树

8.性质

  （1） 一棵非空二叉树的第i层上最多有2的i-1次方个结点。

  （2）深度为k的二叉树中，最多有2的k次方-1个结点。

  （3）对于非空二叉树，若叶子结点数为n0，度数为2的结点数为n2，则n0=n2+1。（可以先设想            一个二叉树只有根节点，二叉树有一个叶节点，也就是这个根节点，没有度数为2的结点；            对这个根节点只添加左孩子或者右孩子的话，依旧只有一个叶节点，没有度数为2的结点；            如果对这个根节点同时添加左孩子与右孩子，这样叶节点+1，度数为2的结点+1）

 （4）有n个结点的完全二叉树的深度为log2（n）的下取整+1。（必须是完全二叉树）

 （5）编号为i的结点，当2*i不超过范围时，左孩子为2*i；当2*i+1不超过范围时，  右孩子为                     2*i+1；父节点为i/2下取整

9.二叉树存储

（1）顺序存储：数组（使用性质5）

（2）链式存储：二叉链表存储，三叉链表存储（多了一个指向父节点的指针）

10.遍历操作

（1）递归遍历

#include<iostream>
using namespace std;

typedef struct bitnode {
    int data;
    bitnode* lchild, *rchild;
}BiTree;

void PreOrder(BiTree* t) {
    if (t == NULL) {
        return;
    }
    cout << t->data;
    PreOrder(t->lchild);
    PreOrder(t->rchild);
}

void InOrder(BiTree* t) {
    if (t == NULL) {
        return;
    }
    PreOrder(t->lchild);
    cout << t->data;
    PreOrder(t->rchild);
}

void PostOrder(BiTree* t) {
    if (t == NULL) {
        return;
    }
    PreOrder(t->lchild);
    PreOrder(t->rchild);
    cout << t->data;
}

int main()
{
    //创建二叉树
    //遍历

    return 0;
}

（2）迭代法遍历

用这个题创建的二叉树

4-14 还原二叉树&&4-15 根据后序和中序遍历输出先序遍历

#include<iostream>
#include<stack>
#include<vector>
using namespace std;

typedef struct bitnode {
    char data;
    bitnode* lchild, *rchild;
}BiTree;

BiTree* get(char preod[], char inod[], int len) {
    int i;
    if (len <= 0) {
        return NULL;
    }
    BiTree* t = (BiTree*)malloc(sizeof(BiTree));
    t->data = preod[0];
    for (i = 0; inod[i] != preod[0]; i++);
    t->lchild = get(preod + 1, inod, i);
    t->rchild = get(preod + i + 1, inod + i + 1, len - i - 1);
    return t;
}

vector<char> InOrder(BiTree* t) {//左中右
    vector<char> result;
    stack<BiTree*> temp;

    if (t != NULL) {
        temp.push(t);
    }

    while (!temp.empty()) {
        bitnode* node = temp.top();
        if (node != NULL) {
            temp.pop();

            if (node->rchild != NULL) {
                temp.push(node->rchild);
            }
            temp.push(node);
            temp.push(NULL);
            if (node->lchild != NULL) {
                temp.push(node->lchild);
            }
        }
        else {
            temp.pop();
            node = temp.top();
            temp.pop();
            result.push_back(node->data);
        }
    }
    return result;
}

vector<char> PreOrder(BiTree* t) {//中左右
    vector<char> result;
    stack<BiTree*> temp;

    if (t != NULL) {
        temp.push(t);
    }

    while (!temp.empty()) {
        bitnode* node = temp.top();
        if (node != NULL) {
            temp.pop();

            if (node->rchild != NULL) {
                temp.push(node->rchild);
            }
            if (node->lchild != NULL) {
                temp.push(node->lchild);
            }
            temp.push(node);
            temp.push(NULL); 
        }
        else {
            temp.pop();
            node = temp.top();
            temp.pop();
            result.push_back(node->data);
        }
    }
    return result;
}

vector<char> PostOrder(BiTree* t) {//左右中
    vector<char> result;
    stack<BiTree*> temp;

    if (t != NULL) {
        temp.push(t);
    }

    while (!temp.empty()) {
        bitnode* node = temp.top();
        if (node != NULL) {
            temp.pop();

            temp.push(node);
            temp.push(NULL);
            if (node->rchild != NULL) {
                temp.push(node->rchild);
            }
            if (node->lchild != NULL) {
                temp.push(node->lchild);
            }
        }
        else {
            temp.pop();
            node = temp.top();
            temp.pop();
            result.push_back(node->data);
        }
    }
    return result;
}


int main()
{
    int n;
    scanf("%d", &n);
    char s1[200], s2[200];
    scanf("%s", &s1);
    scanf("%s", &s2);


    BiTree* t = get(s1, s2, n);
    vector<char> v = InOrder(t);

    for (auto it = v.begin(); it != v.end(); it++) {
        cout << *it;
    }

    return 0;
}

（3）层次遍历

练习题：二叉树的层序遍历 专题

#include<iostream>
#include<queue>
#include<vector>
using namespace std;

typedef struct bitnode {
    char data;
    bitnode* lchild, *rchild;
}BiTree;

BiTree* get(char preod[], char inod[], int len) {
    int i;
    if (len <= 0) {
        return NULL;
    }
    BiTree* t = (BiTree*)malloc(sizeof(BiTree));
    t->data = preod[0];
    for (i = 0; inod[i] != preod[0]; i++);
    t->lchild = get(preod + 1, inod, i);
    t->rchild = get(preod + i + 1, inod + i + 1, len - i - 1);
    return t;
}

vector<char> LevelOrder(BiTree* t) {
    vector<char> result;
    queue<bitnode*> st;

    if (t != NULL) {
        result.push_back(t->data);
        st.push(t);
    }

    bitnode* temp;
    while (!st.empty()) {
        temp = st.front();
        st.pop();

        if (temp->lchild != NULL) {
            result.push_back(temp->lchild->data);
            st.push(temp->lchild);
        }
        if (temp->rchild != NULL) {
            result.push_back(temp->rchild->data);
            st.push(temp->rchild);
        }
    }
    return result;
}


int main()
{
    int n;
    scanf("%d", &n);
    char s1[200], s2[200];
    scanf("%s", &s1);
    scanf("%s", &s2);


    BiTree* t = get(s1, s2, n);
    vector<char> v = LevelOrder(t);

    for (auto it = v.begin(); it != v.end(); it++) {
        cout << *it;
    }

    return 0;
}

11.根据给定序列构造二叉树

例如：给定二叉树的先序序列：ABD0G000CE00F00（0表示空）

#include<iostream>
#include<queue>
#include<vector>
using namespace std;

typedef struct bitnode {
    char data;
    bitnode* lchild, *rchild;
}BiTree;

BiTree* creat() {
    bitnode* node;
    char ch;
    scanf("%c", &ch);
    if (ch == '0') {
        return NULL;
    }
    else {
        node = (bitnode*)malloc(sizeof(bitnode));
        node->data = ch;
        
        node->lchild = creat();
        node->rchild = creat();
    }
    return node;
}

vector<char> LevelOrder(BiTree* t) {
    vector<char> result;
    queue<bitnode*> st;

    if (t != NULL) {
        result.push_back(t->data);
        st.push(t);
    }

    bitnode* temp;
    while (!st.empty()) {
        temp = st.front();
        st.pop();

        if (temp->lchild != NULL) {
            result.push_back(temp->lchild->data);
            st.push(temp->lchild);
        }
        if (temp->rchild != NULL) {
            result.push_back(temp->rchild->data);
            st.push(temp->rchild);
        }
    }
    return result;
}


int main()
{
    BiTree* t = creat();

    vector<char> v = LevelOrder(t);

    for (auto it = v.begin(); it != v.end(); it++) {
        cout << *it;
    }

    return 0;
}

12.查找数据

用四种遍历方式都可以，当用迭代法时，遇到这个元素就直接返回就行；用递归法时，不能直接返回。

13.由遍历顺序恢复二叉树。（1）先序和中序（2）后序与中序

4-14 还原二叉树&&4-15 根据后序和中序遍历输出先序遍历

14.线索二叉树

先序线索二叉树，中序线索二叉树，后序线索二叉树。

#include<iostream>
#include<queue>
#include<vector>
using namespace std;

typedef struct bitnode {
    char data;
    int ltag, rtag;
    bitnode* lchild, * rchild;
}BiTree;

BiTree* get(char preod[], char inod[], int len) {
    int i;
    if (len <= 0) {
        return NULL;
    }
    BiTree* t = (BiTree*)malloc(sizeof(BiTree));
    t->data = preod[0];
    t->ltag = t->rtag = 0;
    for (i = 0; inod[i] != preod[0]; i++);
    t->lchild = get(preod + 1, inod, i);
    t->rchild = get(preod + i + 1, inod + i + 1, len - i - 1);
    return t;
}

bitnode* pre;
void InTreading(bitnode* p) {
    if (p) {
        InTreading(p->lchild);
        if (p->lchild == NULL) {
            p->ltag = 1;
            p->lchild = pre;
        }
        if (pre->rchild == NULL) {
            pre->rtag = 1;
            pre->rchild = p;
        }
        pre = p;
        InTreading(p->rchild);
    }
}


bitnode* InOrderThr(bitnode* T) {
    bitnode* head = (bitnode*)malloc(sizeof(bitnode));
    head->ltag = 0;
    head->rtag = 1;
    head->rchild = head;
    if (!T) {
        head->lchild = head;
    }
    else {
        head->lchild = T;
        pre = head;
        InTreading(T);
        pre->rchild = head;
        pre->rtag = 1; 
        head->rchild = pre;
    }

    return head;
}

bitnode* InPostNode(bitnode* p) {
    bitnode* post;
    post = p->rchild;
    if (p->rtag != 1) {
        while (post->ltag == 0) {
            post = post->lchild;
        }
    }
    return post;
}

void Search(bitnode* head) {
    bitnode* p;
    p = head->lchild;
    while (p->ltag == 0 && p != head) {
        p = p->lchild;
    }
    while (p != head) {
        cout << p->data << " ";
        p = InPostNode(p);
    }
}


int main()
{
    int n;
    scanf("%d", &n);
    char s1[200], s2[200];
    scanf("%s", &s1);
    scanf("%s", &s2);

    
    BiTree* t = get(s1, s2, n);
    t = InOrderThr(t);
    Search(t);

    return 0;
}

15.哈夫曼树

16.哈夫曼编码

17.森林

JYHZZ
关注
专栏目录
二叉树前驱节点与后继节点
hpcds的博客
03-21 3万+
前驱节点：对一棵二叉树进行中序遍历，遍历后的顺序，当前节点的前一个节点为该节点的前驱节点； 后继节点：对一棵二叉树进行中序遍历，遍历后的顺序，当前节点的后一个节点为该节点的后继节点； 例如一颗完全二叉树（1,2,3,4,5,6,7），按照中序遍历后的顺序为：（4,2,5,1,6,3,7），1节点的前驱节点为：5，后继节点为6. 图1：二叉树 若每次遍历二叉树进行查找前驱节点或后继节点，复杂度太高...
数据结构复习总结
Ginbright_Xu的博客
09-29 2761
第一章——绪论 这里介绍了数据结构的基本概念和术语，以及算法和算法时间复杂度的分析方法。主要内容如下。 （1）数据结构是一门研究非数值计算程序设计中操作对象，以及这些对象之间的关系和操作的学科。 （2）数据结构包括两个方面的内容：数据的逻辑结构和存储结构。同一逻辑结构采用不同的存储方法，可以得到不同的存储结构。 ①逻辑结构是从具体问题抽象出来的数学模型，从逻辑关系上描述数据，它与数据的存储无关。根据数据元素之间关系的不同特性，通常有四类基本逻辑结构：集合结构、线性结构、树形结构和图状结构。 ②存储
数据结构总复习
weixin_62351743的博客
02-11 1582
数据结构相关知识点总结
数据结构复习 树&二叉树
AbuliaXu的博客
01-03 982
//又到考试周了，得肝了！！！ 目录 树 树的定义 基本术语 树的存储结构 双亲表示法 孩子表示法 孩子兄弟表示法 二叉树 二叉树的逻辑结构 定义 基本性质 二叉树的遍历 二叉树的存储结构 顺序存储结构 二叉链表 三叉链表 森林 树转换为二叉树 森林转换为二叉树 二叉树转换为树或森林 最优二叉树 哈夫曼算法 哈夫曼编码 线索链表 树 树结构比线性结构复杂，适合描述层次关系的数据。 树的定义 结点：树中的数据元素 树：n个结点(n>=0)的有限
数据结构：树(Tree)【详解】
热门推荐
UniqueUnit的博客
02-26 17万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
数据结构 期末复习
weixin_62438655的博客
12-01 1382
复习数据结构
数据结构复习--树
weixin_43873887的博客
05-18 2365
树和二叉树 内容提纲 树的概念 二叉树的概念 二叉树的存储结构 二叉树基本运算及其实现 二叉树的遍历 二叉树的构造 线索二叉树 哈夫曼树 杂项 树的概念 树的定义 形式化定义： 对于树：T={D, R}，D是包含n个结点的有限集合，当n=0时为空树，否则关系R满足以下条件： 有且仅有一个根节点 除根节点之外，每个节点有且仅有一个前驱结点 每个节点可以有零个或者多个后继结点 递归定义： 树...
专升本数据结构复习
emmmheng的博客
03-03 1万+
数据结构知识点总汇 主要参考书目： 程海英老师的《数据结构（C语言版）》教材 严蔚敏，李冬梅，吴伟民．《数据结构（C语言版）》 说明：这是本人专升本上岸一年后写的，本篇包含知识点和例题总结。因为是当时自己手码的，所以知识点有冗余和顺序错位。如果发现有错误之处，欢迎评论区留言，看到后及时改正，谢谢！最后祝大家好好学习，积极向上，早日上岸！ ① 数据结构(逻辑结构)其4类基本结构：集合、线性结构、树形结构、图状结构 和 网状结构。 ② 物理结构(存储结构)其4种存储结构：顺序存储结构、链式存储结构、索引存储
数据结构复习整理目录
songsongL的博客
07-16 365
文章目录数据结构 数据结构 回到顶部
数据结构复习题
weixin_52093131的博客
01-02 2464
文章目录数据结构 复习题填空选择判断简答存储结构森林阿克曼（Ackerman）函数排序直接选择排序：冒泡排序： 数据结构 复习题 填空 在数据结构中, 从逻辑上能够把数据结构分为 线性结构 非线性结构 数据结构在计算机内存中的表示是指 数据的存储结构 链式存储的特点是利用**指针** 来表示数据元之间的逻辑关系。 对于给定的n个元素，可以构造出的逻辑结构有 集合 树形结构 线性结构 图结构 顺序存储结构是通过==结点物理上相邻==表示元素之间的关系的；
数据结构期末复习思维导图（自制）-树
12-26
数据结构期末复习思维导图（自制）
数据结构复习题整理（附答案）.doc
10-20
数据结构复习题整理（附答案） 本资源摘要信息涵盖了数据结构的基础知识点，包括算法、线性结构、非线性结构、链表、栈、队列、二叉树等。 一、算法 * 算法的重要特性：有穷性、确定性、可行性、输入、输出 * 好...
北京邮电大学809数据结构复习指南
04-24
【北京邮电大学809数据结构复习指南】是一份由成功上岸北邮AI院的学长编写的详尽复习资料，旨在帮助备考北邮研究生考试的学生，特别是那些选择809数据结构作为专业课的考生。复习指南依据北邮研究生招生网的考试大纲...
2018级数据结构复习资料_settlersfme_数据结构_数据结构复习_
09-29
本复习资料“2018级数据结构复习资料_settlersfme_数据结构_数据结构复习”是针对学习者进行期末考试准备的宝贵资源，虽然没有直接的答案，但通过这些资料，学习者可以深入理解和掌握数据结构的基本概念、方法和应用...
数据结构复习通.doc
09-28
数据结构是计算机科学中至关...综上所述，数据结构复习涵盖了逻辑结构、存储结构、抽象数据类型、算法分析和特定数据结构的操作，这些都是理解和设计高效算法的基础。通过深入学习和练习，可以提高解决实际问题的能力。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
最新发布
hjxxlsx的博客
10-06 199
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 769
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1186
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 286
本文主要介绍按既定顺序创建目标数组问题
树数据结构复习：遍历与转换详解
在本次复习课中，我们主要关注的是树型数据结构的相关知识，特别是针对一张特定的树形示意图进行深入理解。首先，让我们来逐一分析题目所涉及的内容： 1. **先根遍历**：在树的先根遍历（前序遍历）中，我们按照根...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值