DS博客作业03--树
| 这个作业属于哪个班级 | 数据结构--网络2011/2012 |
| ---- | ---- | ---- |
| 这个作业的地址 | DS博客作业03--树 |
| 这个作业的目标 | 学习树结构设计及运算操作 |
| 姓名 | 邓宏 |
0.PTA得分截图
1.本周学习总结（5分）
学习总结，请结合树的图形展开分析。
1.1 二叉树结构
1.1.1 二叉树的2种存储结构
顺序存储
借用数组将二叉树中的数据元素存储起来。此方式只适用于完全二叉树，如果想存储普通二叉树，需要将普通二叉树转化为完全二叉树。
使用数组存储完全二叉树时，从数组的起始地址开始，按层次顺序从左往右依次存储完全二叉树中的结点。当提取时，根据完全二叉树的第 2 条性质，可以将二叉树进行还原。
数组中存储为：
根据完全二叉树的第 2 条性质就可以根据数组中的数据重新搭建二叉树的结构。
如果普通二叉树也采取顺序存储的方式，就需要将其转化成完全二叉树，然后再存储，例如：
转化前 ~~~~~~~~~~~~转化后
链式存储
结点结构代码表示：
typedef struct BiTNode
{
TElemType data; //数据域
struct BiTNode *lchild, *rchild; //左右孩子指针
}BiTNode, *BiTree;
顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。
优点：存储密度大（＝1），存储空间利用率高。
缺点：插入或删除元素时不方便。
链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
优点：插入或删除元素时很方便，使用灵活。
缺点：存储密度小（<1），存储空间利用率低。
1.1.2 二叉树的构造
最常用方法
void CreateBiTree(string str, BiTree& T, int index)
{
if (index > str.size()-1)
{
T = NULL;
return;
}
if (str[index] == '#')
{
T = NULL;
}
else
{
T = new BiTNode;
T->data = str[index];
CreateBiTree(str, T->lchild, 2 * index);
CreateBiTree(str, T->rchild, 2 * index + 1);
}
}
先序遍历建二叉树
BTree CreatTree(string str, int &i)
{
BTree bt;
if (i > len - 1) return NULL;
if (str[i] == '#') return NULL;
bt = new BTNode;
bt->data = str[i];
bt->lchild = CreatTree(str, ++i);
bt->rchild = CreatTree(str, ++i);
return bt;
}
已知二叉树先序遍历序列和中序遍历序列建二插树
node* BitryTree(char a[],char b[],int n){
node *T;
int i;
if(!n)
return NULL;即当先树遍历左子树为空时
else{
T = (node *)malloc(sizeof(struct node));
T->data = a[0];
for(i=0;i<n;i++)
{
if(a[0]==b[i])
break;
}
T->left = BitryTree(a+1,b,i);//先遍历左子树
T->right = BitryTree(a+1+i,b+i+1,n-i-1);
}
看法：
最常用第一种建树方法，但主要依具体情节选择合适方法
1.1.3 二叉树的遍历
总结二叉树的4种遍历方式，如何实现。
递归先序遍历二叉树
void PreOrderTraverse(BiTree & t)
{
if(t!=NULL)
{
cout<<t->data;
PreOrderTraverse(t->lchild);
PreOrderTraverse(t->rchild);
}
}
递归中序遍历二叉树
void InOrderTraverse(BiTree & t)
{
if(t!=NULL)
{
InOrderTraverse(t->lchild);
cout<<t->data;
InOrderTraverse(t->rchild);
}
}
递归后序遍历二叉树
void InOrderTraverse(BiTree & t)
{
if(t!=NULL)
{
InOrderTraverse(t->lchild);
InOrderTraverse(t->rchild);
cout<<t->data;
}
}
递归层次遍历二叉树
#include <queue>
void LevelOrder(BTNode* b)
{
BTNode* p;
SqQueue* qu;//定义唤醒队列指针
InitQueue(qu);//初始化队列
enQueue(qu, b);
while (!QueueEmply(qu))
{
deQueueEmpty(qu, p);
printf("%c", p->data);
if (p->lchild != NULL)
enQueue(qu, p->lchild);
if (p->rchild != NULL)
enQueue(qu, p->rchild);
}
DestroyQueue(qu);
}
1.1.4 线索二叉树
建立线索的规则：
（1）如果ptr->lchild为空，则存放指向中序遍历序列中该结点的前驱结点。这个结点称为ptr的中序前驱；
（2）如果ptr->rchild为空，则存放指向中序遍历序列中该结点的后继结点。这个结点称为ptr的中序后继；
声明：
typedef struct node
{
ElemType data;
int ltag, rtag; //增加的线索标记
struct node* lchild;
struct node* rchild;
}TBTNode; //线索二叉树中的节点类型
对二叉树p进行中序线索化
TBTNode* pre;//全局变量
void Thread(TBTNode*& p)
{
if (p != NULL)
{
Thread(p->lchild);//左子树线索化
if (p->lchild == NULL)//左孩子不存在，进行前驱结点线索化
{
p->lchild = pre;//建立当前结点的前驱结点线索
p->ltag = 1;
}
else//p结点的左子树已线索化
p->ltag = 0;
if (pre->rchild == NULL)//对pre的后继结点线索化
{
pre->rchild = p;//建立前驱结点的后继结点线索
pre->rtag = 1;
}
else
p->rtag = 0;
pre = p;
Thread(p->rchild);//右子树线索化
}
}
TBTNode* CreateThread(TBTNode* b)//中序线索化二叉树
{
TBTNode* root;
root = (TBTNode*)malloc(sizeof(TBTNode));//创建头结点
root->ltag = 0; root->rtag = 1;
root->rchild = b;
if (b == NULL)//空二叉树
root->lchild = root;
else
{
root->lchild = b;
pre = root;//pre是结点p的前驱结点，供加线索用
Thread(b);//中序遍历线索化二叉树
pre->rchild = root;//最后处理，加入指向头结点的线索
pre->rtag = 1;
root->rchild = pre;//头结点右线索化
}
return root;
}
1.1.5 二叉树的应用--表达式树
建
void InitExpTree(BTree& T, string str)//建表达式树
{
stack<BTree> s;//存放数字
stack<char> op;//存放运算符
op.push('#');
int i = 0;
while (str[i])//树结点赋值
{
if (!In(str[i]))//数字
{
T = new BiTNode;
T->data = str[i++];
T->lchild = T->rchild = NULL;
s.push(T);
}
else
{
switch (Precede(op.top(), str[i]))
{
case'<':
op.push(str[i]);
i++; break;
case'=':
op.pop();
i++; break;
case'>':
T = new BiTNode;
T->data = op.top();
T->rchild = s.top();
s.pop();
T->lchild = s.top();
s.pop();
s.push(T);
op.pop();
break;
}
}
}
while (op.pop() != '#')
{
T = new BiTNode;
T->data = op.top();
op.pop();
T->rchild = s.top();
s.pop();
T->lchild = s.top();
s.pop();s.push(T);
}
}
计算表达式树
double EvaluateExTree(BTree T)
{
double a, b;
if (T)
{
if (!T->lchild && !T->rchild)
return T->data - '0';
a = EvaluateExTree(T->lchild);
b = EvaluateExTree(T->rchild);
switch (T->data)
{
case'+': return a + b; break;
case'-': return a - b; break;
case'*': return a * b; break;
case'/':
if (b == 0)
{
cout << "divide 0 erroe!" << endl;
exit(0);
}
return a / b; break;
}
}
}
1.2 多叉树结构
1.2.1 多叉树结构
主要介绍孩子兄弟链结构
孩子兄弟表示法就是既表示出每个结点的第一个孩子结点，也表示出每个结点的下一个兄弟结点。孩子兄弟表示法需要为每个结点设计三个域：一个数据元素域、一个指向该结点的第一个孩子结点的指针域、一个指向该结点的下一个兄弟结点的指针域。
声明：
typedef struct TNode
{
ElemType data;//结点的值
struct TNode* hp;//指向兄弟结点
struct TNode* vp;//指向孩子结点
}TSBNode;//孩子兄弟链存储结构中的结点类型
1.2.2 多叉树遍历
void preorder(TR* T)
{
if (T)
{
cout << T->data << " ";
preorder(T->fir);
preorder(T->sib);
}
}
1.3 哈夫曼树
1.3.1 哈夫曼树定义
什么是哈夫曼树？，哈夫曼树解决什么问题？
哈夫曼树也叫最优二叉树哈夫曼树。给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
用途：
判别树：用于描述分类过程的二叉树。
如果每次输入量都很大，那么应该考虑程序运行的时间。
1.3.2 哈夫曼树的结构体
教材是顺序存储结构，也可以自己搜索资料研究哈夫曼的链式结构设计方式。
声明：
typedef struct
{
char data;//结点值
double weight;//权重
int parent;//双亲结点
int lchild, rchild;//左右孩子结点
}HTNode;
1.3.2 哈夫曼树构建及哈夫曼编码
void CreateHT(HTNode ht[], int n)
{
int i, k, lnode, rnode;
double min1, min2;
for (i = 1;i < 2 * n - 1;i++)//所有结点的相关域置初值-1
ht[i].parent = ht[i].lchild = ht[i].rchild = -1;
for (i = n;i <= 2 * n - 2;i++)//构造哈夫曼树的n-个分支结点
{
min1 = min2 = 32767;//lnode和rnode为最小权重的两个结点位置
lnode = rnode = -1;
for(k=0;k<=i-1;k++)//再ht[0...i-1]中找权值最小的两个结点
if (ht[k].parent==-1)//只在尚未构造二叉树的结点中查找
{
if (ht[k].weight < min1)
{
min2 = min1; rnode = lnode;
min1 = ht[k].weight;
lnode = k;
}
else if (ht[k].weight < min2)
{
min2 = ht[k].weight;
rnode = k;
}
}
ht[i].weight = ht[lnode].weight + ht[rnode].weight;
ht[i].lchild = lnode;
ht[i].rchild = rnode;//ht[i]作为双亲结点
ht[lnode].parent = i;
ht[rnode].parent = i;
}
}
void CreateHCode(HTNode ht[], HCode hcd[], int n)
{
int i, j, k;
HCode hc;
for (i = 0;i < n;i++)
{
hc.start = n;
k = i;
j = ht[i].parent;
while (j != -1)//循环至根结点
{
if (ht[j].lchild == k)
hc.cd[hc.start--] == '1';//当前结点时的双亲结点的左孩子
else
hc.cd[hc.start--] == '0';//当前结点时的双亲结点的右孩子
k = j; j = ht[j].parent;
}
hc.start++;//start指向哈夫曼编码最开始字符
hcd[i] = hc;
}
}
1.4 并查集
并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中，其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受;即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间(1~3秒)内计算出试题需要的结果，只能用并查集来描述。
并查集是一种树型的数据结构，用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。常常在使用中以森林来表示。
优势：
并查集是若干个不相交集合，能够实现较快的合并和判断元素所在集合的操作，应用很多，如其求无向图的连通分量个数、最小公共祖先、带限制的作业排序，还有最完美的应用：实现Kruskar算法求最小生成树。
结构体
typedef struct
{
int data;//结点对应人的编号
int rank;//结点对应秩
int parent;//结点对应双亲下标
}UFSTree;//并查集树的结点类型
void MakeSet(UFSTree t[], int n)//初始化并查集树
{
int i;
for (i = 0;i < n;i++)
{
t[i].data = i;//数据为该人的编号
t[i].rank = 0;//秩初始化为0
t[i].parent = i;//双亲初始化为自己
}
}
查找
int FindSet(UFSTree t[], int x)//在并查集中查找集合编号
{
if (x != t[x].parent)//双亲不是自己
return (FindSet(t, t[x].parent));//递归在双亲中找x
else
return x;//双亲是自己，返回x
}
合并：
void UnionSet(UFSTree t[], int x, int y)//两个元素各自所属的集合的合并
{//将x和y所在的子树合并
x = FindSet(t, x);
y = FindSet(t, y);//查找x和y所在的分离集合树的编号
if (t[x].rank > t[y].rank)//y结点的秩小于x结点的秩
t[y].parent = x;//将y连接到x结点上，x作为y的双亲结点
else
{
t[x].parent = y;//将x连接到y结点上，y作为x的双亲结点
if (t[x].parent == t[y].parent)//x和y的秩相同
t[y].rank++;//y的秩加一
}
}
1.5.谈谈你对树的认识及学习体会。
树结构还是很有意思的，因为以前总是要写很多代码，现在到了树的结构，大多数都是直接用递归，代码量少（个别题目除外）。其实最主要的就是二叉树，不管是树还是森林，都可以转换成二叉树，在这个基础上进行操作，其中印象最深的的就是目录树了，虽然说操作起来有点麻烦，但是看到最终的结果还是十分有成就感的。但是结合之前知识点的题目又有点力不足的感觉，例如表达式树，究其原因应该是没有复习的锅了。树在生活中还是很多的，不仅仅是方便查找和存储数据，同时其中的哈夫曼树又可以用于数据的加密，涉及到一点密码学的内容，真的是很有意思了。
2.PTA实验作业（4分）
2.1 二叉树
2.1.1 解题思路及伪代码
运用递归先序创造树结构，将#作为递归出口，然后层次遍历输出
2.1.2 总结解题所用的知识点
1.递归先序创造树结构
2.层次遍历
2.2 目录树
2.2.1 解题思路及伪代码
主要思路：
1.定义结构体node，包含1）名字name（2）指向下级目录指针ctl（3）指向下级文件指针file（4）指向同级目录或文件指针next（取决于它本身是目录还是文件）。
定义一个全局的指针ptr，指向上一个处理完毕的结点，比如一开始在输入“a\b\c”的中,ptr一开始指向root，从root开始处理a，处理完后ptr指向a，然后从ptr（即a）开始处理b，处理完后ptr指向b，再从ptr（即b）开始处理c。
2.处理一行数据时，字符串后带\的为目录，否则为文件。
3.假设插入一个目录类型结点s，从某一结点（设为x）开始，如果x的目录为空，直接插入；如果不为空，从x的指向的目录a开始，s与a比较，如果小于（按字典序排在前面），则在x和a之间插入s即可，否则，s继续跟a的next结点b比较，如果s小于b了，则在a与b之间插入s，以此类推……如果到链表遍历完毕都没有找到比s大的结点，说明s最大，需要放在最后，在遍历结束后直接让链表最后一个结点指向s即可。在s插入完毕后，ptr指向s，表明下一个结点的处理是从ptr结点开始的，如本段开头s的插入是从x结点开始的。
如果s跟x的目录重名了，则不需要插入s，直接令ptr指向x即可，然后开始下一个结点的处理（那就是从x，即ptr开始处理了）。
4.假设插入一个文件类型结点s，方法与上述插入目录结点时类似，只是插入文件结点时，是小于（即按字典序规则排在前面），等于（即重名）的时候插入，因为当
文件重名时，不能说只有一个文件，有n个文件重名那就是有n个文件，所以s仍然需要插入，这里跟目录的插入不同，重名的目录即使有多个也是只看成一个的，所以不需要重复插入了。
5.还要注意，在a和c之间插入b时，需要分情况处理，如果a与b同级，是a的next指向b；如果a比高一级,则a的ctl或者file指针指向b。
2.2.2 总结解题所用的知识点
1.孩子兄弟链
2.后序遍历目录树，对每个结点的子目录和子文件进行排序
3.先序遍历进行输出。
3.阅读代码（0--1分）
代码：
#include <iostream>
#include <cstdio>
using namespace std;
int main() {
long long n, maxnum = -3500000000ll, maxlayer, cnt = 0, flag = 0;
cin >> n;
for(int layer = 0; ; layer++) { // 枚举每一层，习惯上从 0 开始
long long sum = 0, a;
//cout << "<<" << (1 << layer) << endl;
for(int i = 0; i < (1 << layer); i++) { // 每一层的结点个数
cin >> a;
sum += a;
if(++cnt >= n) {
flag = 1;
break;
}
}
//cout << sum << endl;
if(sum > maxnum)
maxnum = sum, maxlayer = layer + 1;
if(flag) break;
}
cout << maxlayer;
return 0;
}
思路：
存储一个完全二叉树，可以使用一维数组存下所有结点。从上到下，从左到右，编号依次增加。可以发现，第一层有 1 个结点，第二层有 2 个，第三层有 4 个，第四层有 8 个……第 i 层有 [公式] 个结点。还可以发现，结点编号为 i 的话，它的左右子节点的编号分别是 2×i 和 2×i+1，不过这个和本题无关。
由于我们知道每一层的节点个数，可以直接输入数据后按层统计，甚至都可以不用数组把这些数字存下来。只要记录好读入的数字个数，在合适的时间退出循环就行。注意 << 符号是左移，1<<layer 的意思就是 [公式] 。如果读到的数字到了 n，那么就可以跳出循环，使用变量 flag 进行标记和判断。
本题有两个需要注意的地方
1.数据可能有小于 0 的，导致每层总和可能小于 0。
2.最多的一层可能有 100000-2^16 大约是 35000 个结点，所以要用 long long 防止总合爆 int。
