第六章 树Word文档格式.docx

第六章 树Word文档格式.docx

《第六章 树Word文档格式.docx》由会员分享，可在线阅读，更多相关《第六章 树Word文档格式.docx（70页珍藏版）》请在冰豆网上搜索。

从根结点出发，到树中的其余结点一定存在着一条路径。

注意，不同子树上的结点之间不存在路径。

但是，如果把树看成是一个图的话（可以把树理解为是图的一个子类），那么我们就可以继承图的路径的定义，认为不同子树上的两个结点应该是有路径的（图论意义上的路径）。

5．森林（forest）是m（m>

=0）棵互不相交的树的集合。

三、树的表示方法和存储结构

树的表示方法有多种，如图6_1采用的就是一种形象的树形表示法；

另外还有一种常用的表示方法“括号表示法”，它的表示方法归纳如下：

先将整棵树的根结点放入一对圆括号中，然后把它的子树由左至右放入括号中，同层子树用圆括号括在一起（同层子树之间用逗号隔开），而对子树也采用同样的方法处理，直到所有的子树都只有一个根结点为止。

用括号表示法表示图6_1的步骤如下：

=（T）

=（1（T1，T2，T3））{A是根结点，有3棵子树，用逗号隔开}

=（1（2（T11，T12），3，4（T31）））{分别对3棵子树做同样的操作}

=（1（2（5，6），3，4（7（T311，T312））））

=（1（2（5，6），3，4（7（8，9））））

实际上，以上方法是按照树的层次逐步展开，直到所有结点都已列出。

树的存储结构也有多种形式，其中使用较多的采是链式存储结构，下面给出几种常见的存储树的数据结构。

1．父亲表示法：

定义一个数组，每个数组元素为一个记录，除了存放一个结点的数据信息外，还存放该结点的父结点编号。

数据结构定义如下：

Constm=10；

{树的结点数}

Typenode=Record

data:

Integer；

{数据域}

parent:

{指针域}

End；

Vartree:

Array[1..m]Ofnode；

这种方法充分利用了树中除根结点外每个结点都有唯一的父结点这个性质，很容易找到树根（可以规定根结点的父结点为0），但找孩子时却需要遍历整个线性表。

2．孩子表示法：

利用单链表，每个结点包括一个数据域和若干个指针域，每个指针都指向一个孩子结点。

由于一般树的各个结点的孩子数不确定，所以指针数应该等于整棵树的度。

当树的度越大时，空指针域所占比例也越大，给存储空间造成很大浪费。

假设树的度为10，树的结点仅存放字符，则这棵树的数据结构定义如下：

{树的度}

Typetree=^node；

node=Record

Char；

child:

Array[1..m]Oftree{指针域，指向若干孩子结点}

Vart:

tree；

注：

空间上的浪费其实可以用“虚开实用”的方法完美地解决，在FreePascal等环境下可以用Getmem、Freemem等过程达到这个目的，这样建立一棵普通树的时间复杂度也是很不错的。

有兴趣的同学可以参考有关书籍与程序。

由于每个结点都只存放各自孩子结点的编号，所以这种方法只能从根（父）结点遍历到子结点，不能从某个子结点返回到它的父结点。

3．父亲孩子表示法：

利用双链表结构，每个结点包括一个数据域和二个指针域，一个指向该结点的若干孩子结点，一个指向其父结点。

克服了上述第1种存储方法的缺点，假设树的度为10，树的结点仅存放字符，则这棵树的数据结构定义如下：

Array[1..m]Oftree；

father:

tree

End；

4．孩子兄弟表示法：

有些程序中需要对兄弟结点进行处理，这种情况下，可以使用另外一种双链表结构，每个结点包括一个数据域和二个指针域，一个指针指向该结点的第一个孩子结点，一个指针指向该结点的下一个兄弟结点。

克服了上述第2种存储方法的缺点，假设树的度为10，树的结点仅存放字符，则这棵树的数据结构定义如下：

firstchild,next:

tree；

四、树的遍历

在应用树结构解决问题时，往往需要按照某种次序获得树中全部结点的信息，这种操作叫做“树的遍历”。

遍历一般按照从左向右的顺序，常用的遍历方法有：

1．先序（根）遍历：

先访问根结点，再从左到右按照先序思想遍历各棵子树。

图6_1先序遍历的结果为：

{1，2，5，6，3，4，7，8，9}；

2．后序（根）遍历：

先从左到右遍历各棵子树，再访问根结点。

图6_1后序遍历的结果为：

{5，6，2，3，8，9，7，4，1}；

3．层次遍历：

按层次从小到大逐个访问，同一层次按照从左到右的次序。

图6_1层次遍历的结果为：

{1，2，3，4，5，6，7，8，9}；

4．叶结点遍历：

有时我们把所有的数据信息都存放在叶结点中，而其余结点都是用来表示数据之间的某种分支或层次关系，这种情况就用这种方法。

图6_1按照这个思想访问的结果为：

{5，6，3，8，9}；

很明显，先序遍历和后序遍历两种方法的定义是递归的，所以在程序实现时往往也是采用递归的思想，既通常所说的“深度优先搜索”。

按照先序遍历思想编写的递归过程如下：

Proceduretra1（t,m）{访问以t为根结点的含有m棵子树的过程}

Begin

Ift<

>

NilThenBegin

Write（t^.data,’’）；

{访问根结点}

ForI:

=1TomDo{前序遍历各子树}

tra1（t^.child[I],m）；

也可以用堆栈的方法编写这个程序，留给读者作为练习。

层次遍历应用也较多，实际上就是我们所说的“广度优先搜索”。

思想如下：

若某个结点被访问，则该结点的子结点应被记录下来，等待被访问。

顺序访问各层次上结点，直至不再有未访问过的结点。

为此，引入一个队列来存储等待访问的子结点，设一个队首和队尾指

针分别表示出队、进队的下标。

程序框架如下：

Constn=100；

Varhead,tail,i:

integer；

q:

array[1..n]oftree；

p:

tail:

=1；

head:

{初始化}

q[tail]:

=t；

tail:

=tail+1；

{t进队}

While（head<

tail）doBegin{队列非空}

=q[head]；

=head+1；

{取出队首结点}

Write（p^.data,‘‘）；

{访问某结点}

Fori:

=1TomDo{该结点的所有子结点按顺序进队}

Ifp^.child[i]<

NilThenBegin

q[tail]:

=p^.child[I]；

例6_1：

单词查找树

[问题描述]在进行文法分析的时候，通常需要检测一个单词是否在我们的单词列表里。

为了提高查找和定位的速度，通常都画出与单词列表所对应的单词查找树，其特点如下：

1．根结点不包含字母，除根结点外每一个结点都仅包含一个大写英文字母；

2．从根结点到某一结点，路径上经过的字母依次连起来所构成的字母序列，称为该结点对应的单词。

单词列表中的每个单词，都是该单词查找树某个结点所对应的单词；

3．在满足上述条件下，该单词查找树的结点数最少。

4．例如图6_2左边的单词列表就对应于右边的单词查找树。

注意，对一个确定的单词列表，请统计对应的单词查找树的结点数（包含根结点）。

[问题输入]

输入文件名为word.in，该文件为一个单词列表，每一行仅包含一个单词和一个换行/回车符。

每个单词仅由大写的英文字母组成，长度不超过63个字母。

文件总长度不超过32K，至少有一行数据。

[问题输出]

输出文件名为word.out，该文件中仅包含一个整数，该整数为单词列表对应的单词查找树的结点数。

[样例输入]

A

AN

ASP

AS

ASC

ASCII

BAS

BASIC

[样例输出]

13图6_2

[算法分析]

首先要对建树的过程有一个了解。

对于当前被处理的单词和当前树：

在根结点的子结点中找单词的第一位字母，若存在则进而在该结点的子结点中寻找第二位……如此下去直到单词结束，即不需要在该树中添加结点；

或单词的第n位不能被找到，即将单词的第n位及其后的字母依次加入单词查找树中去。

但，本问题只是问你结点总数，而非建树方案，且有32K文件，所以应该考虑能不能通过不建树就直接算出结点数？

为了说明问题的本质，我们给出一个定义：

一个单词相对于另一个单词的差：

设单词1的长度为L，且与单词2从第N位开始不一致，则说单词1相对于单词2的差为L-N+1，这是描述单词相似程度的量。

可见，将一个单词加入单词树的时候，须加入的结点数等于该单词树中已有单词的差的最小值。

单词的字典顺序排列后的序列则具有类似的特性，即在一个字典顺序序列中，第m个单词相对于第m-1个单词的差必定是它对于前m-1个单词的差中最小的。

于是，得出建树的等效算法：

①读入文件；

②对单词列表进行字典顺序排序；

③依次计算每个单词对前一单词的差，并把差累加起来。

注意：

第一个单词相对于“空”的差为该单词的长度；

④累加和再加上1（根结点），输出结果。

就给定的样例，按照这个算法求结点数的过程如下表：

表6_1

原单词列表

排序后的列表

差值

总计

输出

1

12

13

2

3

BASIC

[数据结构]先确定32K（32*1024=32768字节）的文件最多有多少单词和字母。

当然应该尽可能地存放较短的单词。

因为单词不重复，所以长度为1的单词（单个字母）最多26个；

长度为2的单词最多为26*26=676个；

因为每个单词后都要一个换行符（换行符在计算机中占2个字节），所以总共已经占用的空间为：

（1+2）*26+（2+2）*676=2782字节；

剩余字节（32768-2782=29986字节）分配给长度为3的单词（长度为3的单词最多有26*26*26=17576个）有29986/（3+2）≈5997。

所以单词数量最多为26+676+5997=6699。

定义一个数组：

a：

array[1..32767]ofchar；

把所有单词连续存放起来，文件中每个单词后的换行符转换成数组中的一个“空格”字符。

这样既省略了一个存放单词长度的数组，又方便且节省了一点空间。

另外为了排序，再设一个数组index:

array[1..6700]ofinteger；

存放每个单词在a中的起始位置。

这样，排序时用a比较，但只要交换index的值就可以了。

[参考程序]

Programp6_1（Input,Output）；

Var

a:

Array[1..32767]OfChar；

index:

Array[1..6700]OfInteger；

n,k,i,j,tot,t:

s,pre,now:

String；

Functioncmp（i,j:

Longint）:

Boolean；

{比较从a[i]开始的字符串和从a[j]开始的字符串

Begin大小，小于则返回False，否则返回True}

While（（a[i]=a[j]）And（Ord（a[i]）<

32）And（Ord（a[j]）<

32））Do

BeginInc（i）；

Inc（j）；

If（a[i]<

a[j]）Thencmp:

=FalseElsecmp:

=True；

Begin{main}

Assign（Input,'

word.in'

）；

Reset（Input）；

Assign（Output,'

word.out'

Rewrite（Output）；

Fillchar（a,sizeof（a）,0）；

n:

=0；

{单词个数}

k:

{下标}

While（NotEof）Do{读入文件中的单词并且存储到数组中}

Begin

Readln（s）；

=n+1；

index[n]:

=k+1；

{第n个单词的首字母起点下标}

=1ToLength（s）Do{存入一个单词}

a[k+i]:

=s[i]；

=k+i+1；

{为下个单词的下标设定好初值,i即为当前单词的长度}

=1TonDo{n个单词的字典排序}

Forj:

=i+1TonDo

Ifcmp（index[i],index[j]）Then

Begint:

=index[i]；

index[i]:

=index[j]；

index[j]:

=t；

tot:

{计数器}

pre:

='

'

；

{前一个单词}

=1TonDo{统计}

now:

j:

{第i个单词的首字母在a数组中的下标为j}

While（Ord（a[j]）<

0）Do{换行符换成了空格}

Beginnow:

=now+a[j]；

j:

=j+1；

{当前处理的单词存入now中}

=1；

While（（pre[j]=now[j]）And（j<

=length（pre）））DoInc（j）；

{求两个单词的差}

=tot+（Length（now）-j+1）；

{累加}

=now；

{把当前单词作为下次比较的前一个单词}

Writeln（tot+1）；

Close（Input）；

Close（Output）；

End.

第二节二叉树

一、二叉树的概念

二叉树（binarytree,简写成BT）是一种特殊的树型结构，它的特点是每个结点至多只有二棵子树，即二叉树中不存在度大于2的结点，而且二叉树的子树有左子树、右子树之分，孩子有左孩子、右孩子之分，其次序不能颠倒，所以二叉树是一棵有序树。

它有如下5种基本形态：

图6_3

第一节讲述的树的一些术语、概念也基本适用于二叉树，但二叉树与树也有很多不同，如：

二叉树的每个结点至多只能有两个结点，二叉树一定是有序的，二叉树可以为空（但树不能为空，至少要有1个结点）。

二、二叉树的性质：

性质1：

在二叉树的第i层上至多有2i-1个结点（i>

=1）。

性质2：

深度为k的二叉树至多有2k–1个结点（k>

特别地，一棵深度为k且有2k–1个结点的二叉树称为满二叉树。

图6_4是深度为4的满二叉树，这种树的特点是每层上的结点数都达到了最大值。

图6_4

可以对满二叉树的结点进行连续编号，约定编号从根结点起，自上而下，从左到右，由此引出完全二叉树的定义：

深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应时，称为完全二叉树。

如图6_5就是一个深度为4，结点数为12的完全二叉树。

图6_5

完全二叉树具有如下特征：

叶结点只可能出现在最下面两层上；

对任一结点，若其右子树深度为m，则其左子树的深度必为m或m+1。

图6_6和图6_7所示的两棵二叉树就不是完全二叉树，请读者思考为什么？

图6_6图6_7

性质3：

对任何一棵二叉树，如果其叶结点数为n0，度为2的结点数为n2，则一定满足：

n0=n2+1。

性质4：

具有n个结点的完全二叉树的深度为trunc（LOG2n）+1（trunc为取整函数）

性质5：

一棵n个结点的完全二叉树，对于任一编号为i结点，有：

1．如果i=1,则结点i为根，无父结点；

如果i>

1,则其父结点编号为trunc（i/2）。

2．如果2*i>

n，则结点i为叶结点；

否则左孩子编号为2*i。

3．如果2*i+1>

n，则结点i无右孩子；

否则右孩子编号为2*i+1。

三、二叉树的存储结构

二叉树的存储结构与普通树的存储结构基本相同，有链式和顺序存储两种方法。

1．链式存储结构:

单链表结构或双链表结构，基本数据结构定义如下：

{单链表结构}

lchild,rchild:

tree{指针域：

分别指向左、右孩子}

Varbt:

{双链表结构}

lchild,rchild,father:

分别指向左、右孩子及父结点}

如图6_8左边所示的一棵二叉树用单链表就可以表示成右边的形式。

bt

图6_8

2．顺序存储结构:

即几个数组加一个指针变量，一般用在满二叉树和完全二叉树中，将每个结点编号后作为数组的下标变量值，基本数据结构定义如下：

Constn=10；

{最多10个结点}

Vardata:

Array[1..n]OfChar；

{n个结点的数据域}

lchild:

Array[1..n]OfInteger；

{n个结点的左孩子}

rchild:

{n个结点的右孩子}

bt:

{根结点指针}

这种结构可以很方便地从根结点往下遍历，但是如果想从某个分支结点或叶结点遍历整棵树，则还需设置一个父结点数组，操作也教麻烦。

其实如果树的结点较少，也可采用邻接矩阵的方法，这样操作起来也很方便。

二叉树在处理表达式时经常用到，一般用叶结点表示运算数，分支结点表示运算符。

这样的二叉树称为表达式树，如表达式（a+b/c）*（d-e）就可以表示成图6_9。

图6_9

例6_2：

医院设置

[问题描述]设有一棵二叉树（如图6_10），其中圈中的数字表示结点中居民的人口，圈边上数字表示结点编号。

现在要求在某个结点上建立一个医院，使所有居民所走的路程之和为最小，同时约定，相邻接点之间的距离为1。

就本图而言，若医院建在1处，则距离和=4+12+2*20+2*40=136；

若医院建在3处，则距离和=4*2+13+20+40=81……

[输入格式]

输入文件名为hospital.in，其中第一行一个整数n，表示树的结点数（n<

=100）。

接下来的n行每行描述了一个结点的状况，包含三个整数，整数之间用空格（一个或多个）分隔，其中：

第一个数为居民人口数；

第二个数为左链接，为0表示无链接；

第三个数为右链接。

[输出格式]

输出文件名为hospital.out，该文件只有一个整数，表示最小距离和。

[样例输入]

5

1323

400

1245

2000

4000

[样例输出]

81

[问题分析]这是一道简单的二叉树应用问题，问题中的结点数并不多，数据规模也不大，采用邻接矩阵存储，用Floyed法求出任意两结点之间的最短路径长，然后穷举医院可能建立的n个结点位置，找出一个最小距离的位置即可。

当然也可以用双链表结构或带父结点信息的数组存储结构来解决，但实际操作稍微麻烦了一点。

Programp6_2（Input,Output）；

Vara:

Array[1..100]OfLongint；

g:

Array[1..100,1..100]OfLongint；

n,i,j,k,l,r,min,total:

Longint；

Assign（Input,'

hospital.in'

Assign（Output,'

Rewrite（Output）；