树与二叉树学习笔记

最新推荐文章于 2024-11-06 23:06:53 发布
最新推荐文章于 2024-11-06 23:06:53 发布
阅读量1k 收藏 19
点赞数 17
分类专栏： 数据结构与算法 文章标签： 笔记 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53652592/article/details/140587914
版权

树与二叉树

计算机中的树

树的概念

  计算机中的树与现实生活中的树结构是类似的，但是计算机中的树型结构更加抽象化。在计算机中的树型结构具备以下几个特点：

  • 除了根节点，每个结点都具有唯一父节点。
  • 每个结点可以有若干个子节点。
  • 树型结构具备层次关系。
  • 边与结点之间，具备无循环的特性。

树的类型

  • 二叉树（Binary Tree）：

    每个节点最多有两个子节点，通常称为左子节点和右子节点。

  • 多叉树

    每个节点最多不止有两个子节点，比如说字典树、和双数组字典树。

    在这里插入图片描述

什么是二叉树

二叉树：定义与特点

  • 每个结点最多只有两个子节点。
  • 遍历和结构操作方便。
  • 满足递归的基本性质，相关操作可以借助递归方式完成。
  • 二叉树在计算机领域应用广泛。

二叉树：前序、中序、后序遍历

  • 前序遍历

所谓前序遍历，指的就是遍历顺序按照：根、左、右 的方式进行。

在这里插入图片描述

	// typedef struct Node {
	//   int val;
	// 	 struct Node *left, *right;	
	// } Node;
	
	void preOrder(Node *root) {
		if (root == NULL) return ;
		printf("%d ", root->val);
		preOrder(root->left);
		preOrder(root->right);
		return ;
	}
  • 中序遍历

中序遍历的遍历顺序按照：左、根、右 的方式进行。

在这里插入图片描述

// typedef struct Node {
//   int val;
// 	 struct Node *left, *right;	
// } Node;

void inOrder(Node *root) {
	if (root == NULL) return ;
	inOrder(root->left);
	printf("%d ", root->val);
	inOrder(root->right);
	return ;
}
  • 后序遍历

后序遍历的遍历顺序是按照：左、右、根的方式

在这里插入图片描述

// typedef struct Node {
//   int val;
// 	 struct Node *left, *right;	
// } Node;

void lastOrder(Node *root) {
	if (root == NULL) return ;
	lastOrder(root->left);
	lastOrder(root->right);
	printf("%d ", root->val);
	return ;
}

二叉树：深度、广度优先遍历

  • 深度优先遍历(DFS)

深度优先遍历，其遍历方式就是，沿着其中一条路径一直走到底，当无路可走时，就需要按照原来的路径回退一步，继续搜索其他结点，重复原来的操作。（不撞南墙不回头）

在这里插入图片描述

// typedef struct Node {
//    int key;
//    struct Node *lchild, *rchild;
//} Node;

int tot = 0;

void dfs(Node *root) {
    if (root == NULL) return ;
    int l, r;
    l = tot;
    tot += 1;
    dfs(root->lchild);
    dfs(root->rchild);
    r = tot; 
    printf("%d : l[%d] | r[%d]\n", root->key, l, r);
    return ;
}
  • 广度优先遍历(BFS)

广度优先遍历，也可称之为层序遍历，因为将树型结构看成是一个金子塔，那么BFS就是从顶向底层遍历。

在这里插入图片描述

// typedef struct Node {
//    int key;
//    struct Node *lchild, *rchild;
//} Node;

#define MAX_QUEUE 15

void bfs(Node *root) {
   if (root == NULL) return ;

    Node *array[MAX_QUEUE] = {0};
    #undef MAX_QUEUE
    int head = 0, tail = 0;
    array[tail++] = root;
    while (tail != head) {
        Node *tmp = array[head++];
        if (tmp->lchild) array[tail++] = tmp->lchild;
        if (tmp->rchild) array[tail++] = tmp->rchild;
        printf("%d ", tmp->key);
    }
    printf("\n");
    return ;
}

二叉树：线索化

二叉树的线索化，其实就是将左右子节点为空的结点，重复利用起来，为特定的遍历方式，建立线索化，这样在完成某一个遍历顺序时，可以达到线性复杂度的效率。摆脱递归式遍历的资源浪费问题。

  • 中序遍历线索化

中序遍历的线索化，可以将当前结点中子节点为空的结点指向中序遍历的前驱或者后继结点，即当左孩子为空时，则指向中序遍历中，当前结点的前驱结点，当右孩子为空时，则指向中序遍历中，当前结点的后继结点。

在这里插入图片描述

  • 中序遍历线索化建立
 //typedef struct Node {
 //   int key;
 //    int ltag, rtag;
 //   struct Node *lchild, *rchild;
 // } Node;

Node *pre_node = NULL, *in_node = NULL;
void __build_thread(Node *root) {
    if (root == NULL) return ;
    if (root->ltag == 0) __build_thread(root->lchild);
    if (in_node == NULL) in_node = root;
    if (pre_node && root->lchild == NULL) {
        root->lchild = pre_node;
        root->ltag = 1;
    }
    if (pre_node && pre_node->rchild == NULL) {
        pre_node->rchild = root;
        pre_node->rtag = 1;
    }
    pre_node = root;
    if (root->rtag == 0) __build_thread(root->rchild);
    return ;
}

void build_thread(Node *root) {
    __build_thread(root);
    pre_node->rchild = NULL;
    pre_node->rtag = 1;
    return ;
}
  • 中序线索化遍历
 //typedef struct Node {
 //   int key;
 //    int ltag, rtag;
 //   struct Node *lchild, *rchild;
 // } Node;

Node *getNextNode(Node *root) { 
    if (root->rtag == 1) return root->rchild;
    root = root->rchild;
    while (root->ltag == 0 && root->lchild) root = root->lchild;
    return root;
}

二叉树：序列化与反序列化

  • 序列化(Serialize)

二叉树的序列化，指的是将二叉树的表示方法转化为字符串形式，即广义表表示方法。

在这里插入图片描述

//序列化
#define MAX_CHR 1000

char buff[MAX_CHR + 5];
int len = 0;

void serialize(Node *root) {
    if (root == NULL) return ;
    len += sprintf(buff + len, "%d", KEY(root));
    if (root->lchild == NULL && root->rchild == NULL) return ;
    len += sprintf(buff + len, "(");
    serialize(root->lchild);
    len += sprintf(buff + len, ",");
    serialize(root->rchild);
    len += sprintf(buff + len, ")");
    return ;
}
  • 反序列化(Deserialize)

二叉树的反序列化，就是将字符串（广义表形式）表示的二叉树又转换为树节点的形式。由于二叉树满足递归的性质，因此可以借助栈完成反序列化

在这里插入图片描述

//反序列化

Node *deserialize(char *str) {
    Node *root = NULL, *preNode = NULL;
    
    Node **array = (Node **)malloc(sizeof(Node *) * MAX_CHR);

    int top = -1, scode = 0, flag = 0;

    for (int i = 0; str[i]; i++) {
        switch (scode) {
            case 0: {
                //读取关键词
                if (str[i] <= '9' && str[i] >= '0') {
                    scode = 1;//读取数字
                } else if (str[i] == '(') {
                    scode = 2;//入栈新元素
                } else if (str[i] == ',') {
                    scode = 3;//修改flag
                } else if (str[i] == ')') {
                    scode = 4;//完成栈顶元素的弹出
                }
                i -= 1;
            } break;

            case 1: {
                //读取数字
                int num = 0;
                while (str[i] <= '9' && str[i] >= '0') {
                    num = num * 10 + (str[i] - '0');
                    i++;
                }
                
                preNode = getNewNode(num);
                
                if (root == NULL) {
                    root = preNode;
                } 

                if (top != -1 && flag == 0) {
                    array[top]->lchild = preNode;
                }
                
                if (top != -1 && flag == 1) {
                    array[top]->rchild = preNode;
                }
                scode = 0;
                i -= 1;
            } break;
            case 2: {
                //入栈新元素 "("
                array[++top] = preNode;
                flag = 0;
                scode = 0;
            } break;
            case 3: {
                //遇到逗号 ","
                flag = 1;
                scode = 0;
            } break;
            case 4: {
                //出栈 ")"
                --top;
                flag = 0;
                scode = 0;
            } break;
        }
    }

    return root;
}

haffman树

平均编码长度

  • 定长编码：指的是无论是何种字符，每个字符的编码都是固定长度。
  • 变长编码：即每种字符的编码长度都不是固定的，
  • 问题1：这两种编码方式哪种更加适合用于网络传输？
  • 问题2：如何衡量两种编码方式的优劣？

我们知道最重要的衡量标准，就是单位时间内网络传输数据量的大小之分。假设两种编码方式，都是在相同网络传输环境下，哪种编码方式传输效率更高呢？不言而喻，就是平均编码长度最小的编码方式。

a v g ( L ) = ∑ L i × P i avg(L) = \sum{L_i \times P_i} avg(L)=∑Li​×Pi​

avg(L)表示平均编码长度 = 每一种字符的编码长度与对应字符出现概率的乘积累加和

构建haffman树

  • 首先，统计得到每一种字符的概率
  • 每次将最低频率的两个结点合并成一颗子树
  • 经过了n - 1轮合并，就得到了一颗哈夫曼树
  • 按照左0右1的形式，将编码读取出来

haffman树：代码演示

  • 完整代码
/*************************************************************************
	> File Name: 04.haffmantree.cpp
	> Author: 
	> Mail: 
	> Created Time: Wed 17 Jul 2024 10:23:16 AM CST
 ************************************************************************/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAX_CHR 128

typedef struct Node {
    char ch;
    int freq;
    struct Node *lchild, *rchild;
} Node;

Node *getNewNode(char ch, int freq) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->ch = ch;
    p->freq = freq;
    p->lchild = p->rchild = NULL;
    return p;
}

int findMinNode(Node **arr, int n) {
    int ind = 0;
    for (int i = 1; i <= n; i++) {
        if (arr[ind]->freq > arr[i]->freq ) ind = i;
    }
    return ind;
} 

void swap_node(Node **arr, int i, int j) {
    Node *tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
    return ;
}


Node *buildHaffManTree(Node **arr, int n) {

    for (int i = 1; i < n; i++) {
        //find two node
        int ind1 = findMinNode(arr, n - i);
        swap_node(arr, ind1, n - i);
        
        int ind2 = findMinNode(arr, n - i - 1);
        swap_node(arr, ind2, n - i - 1);
        
        //build new node
        int freq_tmp = arr[n - i]->freq + arr[n - i - 1]->freq;
        Node *new_node = getNewNode(0, freq_tmp);
        new_node->lchild = arr[n - i - 1];
        new_node->rchild = arr[n - i];
        arr[n - i - 1] = new_node;
    }

    return arr[0];
}


char *ch_code[MAX_CHR + 5] = {0};
int k = 0;

void extractHaffManTree(Node *root, char buff[], int k) {
    buff[k] = 0;
    if (root->lchild == NULL && root->rchild == NULL) {
        ch_code[root->ch] = strdup(buff);
        return ;
    }

    buff[k] = '0';
    extractHaffManTree(root->lchild, buff, k + 1);
    buff[k] = '1';
    extractHaffManTree(root->rchild, buff, k + 1);

    return ;
}


void clear(Node *root) {
    if (root == NULL) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

int main() {
    int n;
    char s[10] = {0};
    scanf("%d", &n);
    
    Node **array = (Node **)malloc(sizeof(Node *) * n);

    for (int i = 0; i < n; i++) {
        int freq;
        scanf("%s%d", s, &freq);
        array[i] = getNewNode(s[0], freq);
    }

    Node *root = buildHaffManTree(array, n);
    char buff[1000] = {0};
    extractHaffManTree(root, buff, 0);
    
    for (int i = 0; i < MAX_CHR; i++) {
        if (ch_code[i] == NULL) continue;
        printf("%c : %s\n", i, ch_code[i]);
    }

    clear(root);
    #undef MAX_CHR
    return 0;
}
  • 运行效果展示

在这里插入图片描述

BITORBITS
关注
专栏目录
树与二叉树的学习笔记
qq_73106050的博客
04-16 1155
结点之间存在分支关系结点之间存在层次关系树的基本定义如下：树（Tree）是n（n≥0）个结点的有限集有且仅有一个特定的称为根（Root）的结点n = 0是一个空树当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集T 1 、T 2 、……、T m ，其中每一个集合本身又是一棵树，并且称为根的子树。树如下图所示：注：根节点一定是唯一的，不可能存在多个根节点。子树的个数没有限制，但它们一定是互不相交的不可能出现下面的一个树。
数据结构——树与二叉树学习笔记（一）
weixin_42426940的博客
05-23 716
数据结构——树与二叉树，记录了与树相关的重要知识点，可作为查阅使用。 文章目录1. 树的基本概念1.1 树的概念术语1.2 树的基本性质2. 二叉树的概念2.1 几个特殊的二叉树2.2 二叉树的性质2.3 二叉树的存储结构3. 二叉树的遍历和线索二叉树3.1 递归遍历3.2 非递归遍历3.3 用遍历序列确定二叉树3.4 线索二叉树的构造3.5 线索二叉树的遍历4. 树、森林4.1 树的存储结构4.2 树、森林与二叉树的转换4.3 树/森林的遍历 1. 树的基本概念 1.1 树的概念术语 结点、根、分支、.
二叉树学习笔记
weixin_62921710的博客
08-18 919
树是一种非线性的结构，它是由n个有限结点组成的一个具层次关系的集合。（像一颗倒着的树）特点：有一个特殊的结点，称之为根结点，根结点没有前驱结点除了根节点以外，其余节点别分成M个互不相交的集合，每一个集合又是一颗与树类似的子树，每颗子树的根节点有且只有一个前驱结点，可以有0或n个后继结点除了根结点之外，每一个结点都只有一个父结点。
树和二叉树学习笔记
weixin_51443397的博客
10-26 717
.
学习笔记：树和二叉树
张小憨憨的博客
12-13 1662
第六章 树和二叉树1. 树的定义1.1 结点的分类1.2 结点之间的关系1.3 树的其它相关概念2. 树的抽象数据类型2. 二叉树2.1 二叉树的特点2.2 特殊二叉树3. 二叉树的性质4. 二叉树的存储结构4.1 顺序存储结构构造空二叉树：构造顺序存储的二叉树T：判断二叉树是否为空：返回二叉树的深度：返回二叉树的根：返回处于位置e(层,本层序号)的结点的值：位置e的结点赋新值：返回双亲：返回左孩子：返回右孩子：返回左兄弟：返回右兄弟：前序遍历：中序遍历：后序遍历：层序遍历：逐层、按本层序号输出二叉树：4.
数据结构 第五章 树和二叉树 学习笔记
m0_61126523的博客
05-16 288
一、树 5.1 树的定义 树（Tree）是n个结点的有限集，它或为空树（n=0）；或为非空树，对非空树T； 1）有且仅有一个称之为根的结点； 2）除根节点以外的其余结点可分为m（m>0）个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树（SubTree） 由此可见，树的定义其实是一种递归的定义，子树同样也可以是一棵树，值得注意的是，一个单个的元素也被视为只有一个结点的树。 5.2 树的基本术语 1）结点：树中的一个独立单元，包含对一个数据元素及若干指向其子树的分支。 2）
数据结构学习笔记——树、二叉树和森林
小宇y的博客
07-19 4450
（一）树的概念 （二）结点 叶子结点、孩子结点、双亲结点、兄弟结点： 1、也称为终端结点，它是没有子结点的结点（度为0），例如上图中，D、E、F、G都是叶子结点； 2、一个结点的后继结点称为该结点的，例如上图中，A的孩子结点是B、C； 3、一个结点称为其后继结点的，例如上图中，B、C的双亲结点是A，D、E的双亲结点是B； 4、在同一双亲结点下的孩子结点互为，例如上图中，B、C互为兄弟结点，它们有共同的双亲A，另外D、E互为兄弟结点，它们有共同的双亲B。（三）树的性质 1、树中结点的子结点（孩子）个数称为该，
7.数据结构C++学习笔记——树和二叉树
qq_46417568的博客
05-17 1050
1. 1 树形结构结点之间有分支，具有层次关系树（Tree）是个结点的有限集。若n=0，称为空树。若n>0，则它满足如下两个条件：（1）有且只仅有一个特定的称为根（Root）的结点。（2）其余节点可分为m(m>=0)个互不相交的有限集T1,T2,T3...其中每一个集合本身又是一棵树，并称为根的子树（SubTree）。显然，树的定义是递归的定义。图 1.2.1 树的示意图个节点最多只有两个“叉”的树，普通树（多叉树）若不转为二叉树，则运算很难实现。
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
C+学习笔记+树、堆、二叉树代码
03-28
适合人群：学生，学习初阶数据结构的人群 能学到什么：通过简单的代码，用C语言实现了堆的一些相关接口，比如堆的初始化创建销毁，插入删除，堆排序，TOPK问题解决等等...还有一些链式二叉树的相关内容，在这里为了...
数据结构学习笔记（5.树与二叉树 6.图）
super_song的博客
05-22 971
文章目录第五章 树与二叉树树树的常考性质 第五章 树与二叉树 树 树的基本概念 空树，非空树 非空树特性 树的基本概念 数学描述 子树，子树之间互不相交 树是一种递归定义的结构，任何一个树都可以看做是由根节点和若干个不相交的子树所组成的 树形逻辑结构的应用 结点之间的关系描述 祖先结点：从一个节点出发一直往上走，直到根节点，所遇到的所有节点都是祖先结点 子孙结点：从一个节点出发，下面所有长出的节点都是他的子孙结点 双亲结点：一个结点的直接前驱，就是双亲结点，也叫父结点 孩子结点：一个结点的
【数据结构与算法基础】树与二叉树的互化
wayne_lee_lwc的博客
12-11 4152
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
RK3588开发笔记：CPU、GPU、DDR和NPU模式设置与查询
flypig has a dream！
11-05 241
以下是关于RK3588开发板在和NPU模式设置与查询的开发笔记，希望可以帮助开发者深入了解该芯片的硬件资源配置和调试方法。提示：以下是本篇文章正文内容，下面案例可供参考以上是对RK3588中CPU、GPU、DDR和NPU的模式设置与查询方式的总结。合理设置这些模块的工作频率和模式，可以显著优化RK3588在不同场景中的性能和功耗。
嵌入式通信协议：MODBUS简明学习笔记
weixin_73867577的博客
11-02 378
学习Modbus的简明学习笔记
软件测试学习笔记丨Vue常用指令-条件渲染（v-if）
ceshiren_com的博客
11-05 581
v-show只是简单控制dom元素的display属性。v-if通过操纵dom元素来进行切换显示。
SPI通信详解-学习笔记
qq_45059758的博客
11-04 533
SPI通信
协议栈攻击分类（CISP-PTE笔记）
最新发布
土豆片的博客
11-06 631
1.协议栈自身的脆弱性​ 1）缺乏数据源验证机制​ 2）缺乏完整性验证机制​ 3）缺乏机密性验证机制2.网络接口层攻击3.网络层攻击4.应用层攻击。
RL学习笔记-表格型方法
m0_63213284的博客
11-02 443
参考资料：蘑菇书；《世界冠军带你从零实践强化学习》B站课程。
Spring学习笔记_21——循环依赖
LuckyLay的博客
11-02 689
在Spring中的循环依赖就是指一个或者多个Bean之间存在着互相依赖的关系，并且形成了循环调用。例如：在Spring中，Bean-A依赖Bean-B，Bean-B又依赖Bean-A，Bean-A和Bean-B之间就形成了相互依赖的关系。在创建A对象时，发现A对象依赖了B对象，此时先去创建B对象；创建B对象时，发现B对象又依赖了A对象，此时又区创建A对象……形成死循环。同理，在Spring中多个对象之间有可能存在循环依赖。
严蔚敏《数据结构》解析：树与二叉树
"清华严蔚敏《数据结构》教学笔记，涵盖了树和二叉树的相关概念，包括数据对象、数据关系、树的基本操作、有向树、有序与无序树的对比，以及结点的度、树的度、叶子结点、分支结点等基本术语。同时介绍了二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值