DS博客作业03--树

目录

• 0.PTA得分截图
• 1.本周学习总结（5分）
  • 1.1 二叉树结构
    • 1.1.1 二叉树的2种存储结构
      • 树的顺序存储结构
      • 树的链式存储结构
    • 1.1.2 二叉树的构造
      • 先序遍历序列
      • 中序遍历序列
      • 后序遍历序列
    • 1.1.3 二叉树的遍历
      • 先序遍历
      • 中序遍历
      • 后序遍历
      • 层序遍历
    • 1.1.4 线索二叉树
      • 线索二叉树如何设计？
    • 1.1.5 二叉树的应用--表达式树
  • 1.2 多叉树结构
    • 1.2.1 多叉树结构
    • 1.2.2 多叉树遍历
  • 1.3 哈夫曼树
    • 1.3.1 哈夫曼树定义
      • 什么是哈夫曼树？，哈夫曼树解决什么问题？
    • 1.3.2 哈夫曼树构建及哈夫曼编码
  • 1.4 并查集
  • 1.5.谈谈你对树的认识及学习体会。
• 2.PTA实验作业（4分）
  • 2.1 输出二叉树每层节点
    • 2.1.1 解题思路及伪代码
    • 2.1.2 总结解题所用的知识点
  • 2.2 目录树
    • 2.2.1 解题思路及伪代码
    • 2.2.2 总结解题所用的知识点
• 3.阅读代码（0--1分）

0.PTA得分截图

1.本周学习总结（5分）

学习总结，请结合树的图形展开分析。

1.1 二叉树结构

1.1.1 二叉树的2种存储结构

树的顺序存储和链式存储结构，并分析优缺点。

树的顺序存储结构

完全二叉树：按从上至下、从左到右顺序存储，n个结点的完全二叉树的结点父子关系

非根节点（序号i>1）的父结点的序号是 [i/2]
结点（序号为i）的左孩子结点的序号是2i（[2i<=n] ，否则没有左孩子）
结点（序号为i）的右孩子结点的序号是2i+1（[2i+1<=n] ，否则没有右孩子）

而一般树用顺序存储结构，较容易造成空间上的浪费。

树的链式存储结构

每个结点的结构的代码定义

typedef struct TreeNode *BinTree;
struct TreeNode{
  ElementType Data;
  BinTree Left;
  BinTree Right;
}

结构：

如图，从一个头结点开始，左孩子的指针指向一个子树，右孩子的一个指针指向一个子树，从而构成整棵树。
这就是利用链表的结构，来存储的树。

1.1.2 二叉树的构造

总结二叉树的几种构造方法。分析你对这些构造方法的看法。务必介绍如何通过先序遍历序列和中序遍历序列、后序遍历序列和中序遍历序列构造二叉树。

如图二叉树，前中后三种遍历都是利用递归的结构来进行遍历的，而先序遍历是先访问根节点，之后再访问其左子树跟右子树，同理中序遍历是先左子树
然后再进行根节点的访问跟右子树的访问，而后序则是先左右子树，后根节点。
而转换成构造，无非也是一种遍历，先创建一个树结点，然后看序列来创建左子树或者右子树，或者给根节点赋值。

先序遍历序列

代码实现

BTree CreatTree(char* str)//创建二叉树
{
	if (str[i] == '#' || !str[i])
	{
		i++;
		return NULL;
	}
	BTree T;
	T = new TNode;
	T->data = str[i++];
	T->lchild = CreatTree(str);
	T->rchild = CreatTree(str);
	return T;
}

如果，则先创建根节点a,然后赋值，之后进入左子树的构造，在左子树里重复该模式，知道遇到#，构建右子树。

中序遍历序列

中序遍历是先进入左子树的构建,一直到#，然后才开始给根节点赋值，所以a就会在原来c的位置，进入右子树的构建，还是会优先构建左子树，所以c会出现在e的位置。

后序遍历序列

后序遍历如上所述，则先进入左右子树的构建，则赋值a后，因为原来的b有右子树，所以b结点并不会出现在原来的位置，而是会先进行左右子树的遍历，直到到达原来的g的位置，因为g的左右并无节点了，然后赋值后往上赋值，到原来的d的位置，但却不进行赋值，先构建右子树。

• 如此便是前中后三种序列的构建，实际的应用中，只需更改下赋值跟递归的顺序，差别其实不大。

1.1.3 二叉树的遍历

总结二叉树的4种遍历方式，如何实现。
二叉树的遍历（traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有的结点，使得每个结点被访问依次且仅被访问一次。
四种遍历方式分别为：先序遍历、中序遍历、后序遍历、层序遍历。

先序遍历

前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。
若二叉树为空则结束返回，否则：
（1）访问根结点。
（2）前序遍历左子树。
（3）前序遍历右子树 。
已知后序遍历和中序遍历，就能确定前序遍历。

void preorder(BinTree BT)
{
    if (!BT)
        return;
    if (!BT->Left && !BT->Right)
        printf(" %c", BT->Data);
   preorder(BT->Left);
   preorder(BT->Right);
}

中序遍历

中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。若二叉树为空则结束返回，否则：
（1）中序遍历左子树
（2）访问根结点
（3）中序遍历右子树
已知前序遍历和后序遍历，不能确定中序遍历。

void inorder(BinTree BT)
{
    if (!BT)
        return;
    
    inorder(BT->Left);
    if (!BT->Left && !BT->Right)
        printf(" %c", BT->Data);
    inorder(BT->Right);
}

后序遍历

后序遍历是二叉树遍历的一种。后序遍历指在访问根结点、遍历左子树与遍历右子树三者中，首先遍历左子树，
然后遍历右子树，最后遍历访问根结点，在遍历左、右子树时，仍然先遍历左子树，然后遍历右子树，最后遍历根结点。

（1）若二叉树为空，结束
(2）后序遍历左子树
(3）后序遍历右子树
(4）访问根结点

void postorder(BinTree BT)
{
    if (!BT)
        return;
    
    postorder(BT->Left);
    postorder(BT->Right);
    if (!BT->Left && !BT->Right)
        printf(" %c", BT->Data);
}

层序遍历

层序遍历，主要运用队列的结构，来对一层一层的结点先后进行遍历，如果是同一层的结点，就先入队，然后读完上一层后，
就继续出队下一层的结点，然后再将下一层结点的左子树跟右子树的结点入队，再输出，以便能够达到保存一层层的结点进行输出

图的思维过程：
A入队
访问队首A，左儿子不为空，B入队，右儿子不为空，C入队，A出队
访问队首B，左右儿子为空，不用操作，B出队
访问队首C，同步骤2
访问队首D，同步骤3
访问队首E，同步骤2
访问队首F，同步骤3
访问队首G，同步骤3
遍历结果 ABCDEFG

void LevelTraversal(BinTree T)
{
    if (!T)
    {
        cout << "NULL";
        return;
    }
    BinTree p;
    queue<BinTree>q;
    q.push(T);
    int flag = 1;
    while (!(q.empty()))
    {
        p = q.front();//头结点
        q.pop();//弹出头结点
        if (flag)//访问结点
        {   
            cout << p->Data;
            flag = 0;
        }
        else if (!flag)
            cout << " " << p->Data;
        if (p->Left != NULL)
            q.push(p->Left);
        if (p->Right != NULL)
            q.push(p->Right);
    }
}

1.1.4 线索二叉树

线索二叉树如何设计？

按照某种遍历方式对二叉树进行遍历，可以把二叉树中所有结点排序为一个线性序列。在该序列中，除第一个结点外每个结点有且仅有一个直接前驱结点；
除最后一个结点外每一个结点有且仅有一个直接后继结点。这些指向直接前驱结点和指向直接后续结点的指针被称为线索（Thread），加了线索的二叉树称为线索二叉树。
建立线索二叉树，或者说对二叉树线索化，实质上就是遍历一颗二叉树。在遍历过程中，访问结点的场所是检查当前的左，右指针域是否为空，将它们改为指向前驱结点或后续结点的线索。
为实现这一过程，设指针pre始终指向刚刚访问的结点，即若指针p指向当前结点，则pre指向它的前驱，以便设线索。
另外，在对一颗二叉树加线索时，必须首先申请一个头结点，建立头结点与二叉树的跟结点的指向关系，对二叉树线索化后，还需建立最后一个结点与头结点之间的线索。

iThrNodeType *pre;
 
BiThrTree InOrderThr(BiThrTree T)
 
{   /*中序遍历二叉树T，并将其中序线索化，pre为全局变量*/
 
    BiThrTree head;
 
    head=(BitThrNodeType *)malloc（sizeof（BiThrType））;/*设申请头结点成功*/
 
    head->ltag=0;head->rtag=1;/*建立头结点*/
 
    head->rchild=head;/*右指针回指*/
 
    if(！T)head->lchild=head;/*若二叉树为空，则左指针回指*/
 
    else{head->lchild=T;pre=head;
 
            InThreading(T);/*中序遍历进行中序线索化*/
 
            pre->rchild=head;
 
            pre->rtag=1;/*最后一个结点线索化*/
 
            head->rchild=pre;
 
            };
 
     return head;
 
}
 
void InThreading(BiThrTree p)
 
{/*通过中序遍历进行中序线索化*/
 
     if(p)
 
       {InThreading(p->lchild);/*左子树线索化*/
 
         if(p->lchild==NULL)/*前驱线索*/
 
            {p->ltag=1;
 
             p->lchild=pre;
 
            }
 
          if(p->lchild==NULL)/*后续线索*/
 
            {p->rtag=1;
 
             p->rchild=pre;
 
            }
 
          pre=p;
 
          InThreading(p->rchild);/*右子树线索化*/
 
       }
 
}

中序线索二叉树特点？如何在中序线索二叉树查找前驱和后继？

左指针为空时指向的便是前驱，右指针为空时指向的便是后继

1.1.5 二叉树的应用--表达式树

介绍表达式树如何构造

1. 依次读取表达式；
2. 如果是操作数，则将该操作数压入栈中；
3. 如果是操作符，则弹出栈中的两个操作数，第一个弹出的操作数作为右孩子，第二个弹出的操作数作为左孩子；然后再将该操作符压入栈中。
   这样下去，就可以建立一颗完整的表达式树。

如何计算表达式树
从操作数的栈中弹出两个数，再从操作符的栈中弹出一个符号，进行计算，得出的数再压入数栈中
如此循环，直至栈中清空，得出的最后一个数即为该表达式计算出来的结果。

1.2 多叉树结构

1.2.1 多叉树结构

主要介绍孩子兄弟链结构
孩子兄弟链表示法树的一种存储方式，每个结点由三部分组成：存储数据元素值的数据部分、指向它的第一个子结点的指针、指向它的兄弟结点的指针。

typedef struct node
{
    char data;
    struct node *sublist; //孩子链指针
    struct node *link;//兄弟链指针
}BTNode;

如此，以父节点指向第一个子节点，该层的其他结点存储为链表结构，即第一个子节点指向后续的结点。
这样存储方便了树的结构的构造，在多叉树的应用中，不需要在结构体中添加太多指向后继结点的指针元素。
但其劣势也很明显，不方便找到父亲结点。

1.2.2 多叉树遍历

介绍先序遍历做法
二叉树的先序遍历是优先输出根节点，后继续递归进入下一层的左孩子。
多叉树的遍历也类似，
1.访问根节点，
2.进行第一个孩子的优先的递归遍历，后进行后面其余孩子的递归遍历。
两者皆用递归的结构，且原理类似。

1.3 哈夫曼树

1.3.1 哈夫曼树定义

什么是哈夫曼树？，哈夫曼树解决什么问题？

给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。
哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。
树的路径长度是从树根到每一结点的路径长度之和，记为WPL=（W1L1+W2L2+W3L3+...+WnLn），N个权值Wi（i=1,2,...n）构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li（i=1,2,...n）。
可以证明霍夫曼树的WPL是最小的。
这种结构被用于电报的编码中，让使用频率高的用短码，使用频率低的用长码，以优化整个报文编码。

1.3.2 哈夫曼树构建及哈夫曼编码

结合一组叶子节点的数据，介绍如何构造哈夫曼树及哈夫曼编码。

哈夫曼树的树结构为二叉树，采用自下而上的构建方式

如图数据，找到两个最小的权的数据进行合并成一个子树

重复以上，再找到两个最小数进行合并

第三次进行合并

构成了最小带权路径的哈夫曼树

用0标注左枝干，1标注右枝干
则编码即为，头结点，到各字母的所经过的边的值的合并。
A，B，C，D对应的哈夫曼编码分别为：111，10，110，0。

1.4 并查集

在计算机科学中，并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（union-find algorithm）定义了两个用于此数据结构的操作：
Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
Union：将两个子集合并成同一个集合。
由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（union-find data structure）或合并-查找集合（merge-find set）。其他的重要方法，MakeSet，用于建立单元素集合。有了这些方法，许多经典的划分问题可以被解决。
为了更加精确的定义这些方法，需要定义如何表示集合。一种常用的策略是为每个集合选定一个固定的元素，称为代表，以表示整个集合。接着，Find(x) 返回 x 所属集合的代表，而 Union 使用两个集合的代表作为参数。

结构声明如下

typedef struct node { 
int data;              //结点对应人的编号
int rank;              //结点秩：子树的高度，合并用
int parent;            //结点对应双亲下标
} UFSTree;             //并查集树的结点类型

初始化

void MAKE_SET(UFSTree t[]，int n)//初始化并查集树
{
  int i;
  for(i=1;i<=n;i++)
  {
    t[i].data=0;  //数据为该人的编号
    t[i].rank=0;  //秩初始化为0
    t[i].parent=i;//双亲初始化指向自己
}

查找一个元素的集合

int FIND SET (UFSTree t[], int x) {    //在x所在的子树中查找集合编号
if (x!=t[x]. parent)                   //双亲不是自己
return(FIND-SET(t,t[x] . parent);      //递归在双亲中找x
else
return(x);                             //双亲是自己，返回x
}

合并两个元素各自所属的集合

void UNION(UFSTree t[], int x, int y)  //将x和y所在的子树合并
{
  x=FIND-SET(t,x);                         //套找*所在分离集合树的编号
  y=FIND SET(t,y);                         //查找y所在分离集合树的编号
  if (t[x].rank > t[y].rank)               //y结点的秩小于x结点的秩
    t[y].parent=x;                         //将y连到x结点上,*作为y的双亲结点
  else                                     //y结点的秩大于等于x结点的科
  {
  t[x].parent=y;                           //将x连到y结点上,y作为x的双亲结点
  if (t[x].rank==t[y]. rank)               //x和y结点的秩相同
  t[y].rank++;                             //y结点的秩增
  }
}

1.5.谈谈你对树的认识及学习体会。

2.PTA实验作业（4分）

此处请放置下面2题代码所在码云地址(markdown插入代码所在的链接)。如何上传VS代码到码云

2.1 输出二叉树每层节点

输出二叉树每层节点

2.1.1 解题思路及伪代码

主要是利用队列的结构，使树按照层次来进行输出

伪代码

if 该树为空
  输出NULL
创建树节点p ， 队列q
h记录层数,next 保存队列进队的下一层的层数,n为遍历的该层的层数
for h =1 to 队列不为空
  输出h
  while 队列不为空且i<n
    出队一个树节点赋给p
    if p为有数据的结点
      输出p的值
      然后进行p的左右孩子的出队并且next++
      i++
  End While
  n = next 将下层结点的数保存的该层进行下一轮遍历
  next =0
end for
 
 

2.1.2 总结解题所用的知识点

所用的是树的构造还有树的层次遍历，队列的应用

2.2 目录树

2.2.1 解题思路及伪代码

2.2.2 总结解题所用的知识点

3.阅读代码（0--1分）

找1份优秀代码，理解代码功能，并讲出你所选代码优点及可以学习地方。主要找以下类型代码：

3.1 不同的二叉搜索树
可截图，或复制代码，需要用代码符号渲染。

int numTrees(int n) {
    int G[n + 1];
    memset(G, 0, sizeof(G));
    G[0] = G[1] = 1;
    for (int i = 2; i <= n; ++i) {
        for (int j = 1; j <= i; ++j) {
            G[i] += G[j - 1] * G[i - j];
        }
    }
    return G[n];
}
 

3.2 该题的设计思路及伪代码
请用图形方式展示解决方法。同时分析该题的算法时间复杂度和空间复杂度。
动态规划法：

以i作为根节点，0-i-1作为左子树的根，i+1 -n 作为右子树的根

G(n): 长度为 n 的序列能构成的不同二叉搜索树的个数。
F(i, n)F(i,n): 以 i 为根、序列长度为 n 的不同二叉搜索树个数 (1≤i≤n)。

所以从头开始算G[]的值直至算至G[n]。
伪代码

定义数组G[]储存不同长度的搜索树的种类数量
初始化G
for 2 to n
  for 1 to i
    根据公式计算G[I]的值
返回G[n]

3.3 分析该题目解题优势及难点。
难点主要是对公式的推理分析，类似于前面所学的斐波那系数都是从头开始计算的，这种都是依赖与数学
的方式，找出规律整合出表达式。解题也给我提供了一种新的思路，不一定要用穷举的方式来做出题目，还可以对数据的结构进行分析，然后整合出更高效的表达计算方式。