第六章二叉树和树.ppt

《第六章二叉树和树.ppt》由会员分享，可在线阅读，更多相关《第六章二叉树和树.ppt（88页珍藏版）》请在三一文库上搜索。

1、第六章 二叉树和树,数据结构中的一种，属于非线性结构。,一、教学内容： 1、 二叉树的定义、性质及运算； 2、二叉树的存储结构（顺序、链式表示） 3、二叉树遍历； 4、树和森林的概念（树的定义、树的术语、性质及运算）； 5、树的存储结构；树、森林与二叉树的转换；遍历树；遍历森林 6、哈夫曼树、哈夫曼编码。 二、教学要求： 1、熟练掌握二叉树的结构特性，熟悉二叉树的各种存储结构的特点及适用范围； 2 、熟练掌握二叉树的遍历方法及遍历算法； 3 、了解树和森林的概念。包括树的定义、树的术语和性质； 4、熟悉树的各种存储结构及其特点，掌握树、森林与二叉树的转换方法 5、掌握建立哈夫曼树和哈夫曼编码的

2、方法及带权路径长度的计算。,6.1 二叉树 定义 定义：二叉树是n(n0)个结点的有限集，它或为空树(n=0)，或由一个根结点和两棵分别称为根的左子树和右子树的互不相交的二叉树构成 特点 每个结点至多有二棵子树(即不存在度大于2的结点) 二叉树的子树有左、右之分，且其次序不能任意颠倒 基本形态,基本术语 结点和根结点表示树中的元素，包括数据项及若干指向其子树的分支 结点的度结点拥有的子树数 叶子结点（终端结点）度为0的结点 非叶结点（非终端结点）度不为0的结点 孩子结点拥有的子树的根称为该结点的孩子,分支：结点拥有的子树称为其分支。 双亲(parents)孩子结点的上层结点叫该结点的双亲 兄弟

3、(sibling)同一双亲的孩子 祖先和子孙结点： 二叉树的度一棵二叉树中最大的结点度数 结点的层次(level)从根结点算起，根为第一层，它的孩子为第二层 深度(depth)树中结点的最大层次数,二叉树性质 性质1：二叉树的第i层上最多拥有2 i-1个结点。,证明：用归纳法证明之 i=1时，只有一个根结点， 是对的 假设对所有j(1ji)命题成立，即第j层上至多有 个结点 那么，第i-1层至多有 个结点 又二叉树每个结点的度至多为2 第i层上最大结点数是第i-1层的2倍，即 故命题得证,性质2：深度为k的二叉树至多有 个结点(k1),证明：由性质1，可得深度为k 的二叉树最大结点数是,性质3

4、：对任何一棵非空二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1,证明：n1为二叉树T中度为1的结点数 因为：二叉树中所有结点的度均小于或等于2 所以：其结点总数n=n0+n1+n2 又二叉树中，除根结点外，其余结点都只有一个 分支进入 设B为分支总数，则n=B+1 又：分支由度为1和度为2的结点射出，B=n1+2n2 于是，n=B+1=n1+2n2+1=n0+n1+n2 n0=n2+1,几种特殊形式的二叉树 满二叉树 定义：,特点：每一层上的结点数都是最大结点数 完全二叉树 定义：深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结

5、点一一对应时，称为完全二叉树。（编号从1开始按层次进行） 特点: 叶子结点只可能在层次最大的两层上出现; 对任一结点，若其右分支下子孙的最大层次为l，则其左分支下子孙的最大层次必为l 或l+1,思考： 深度为n的完全二叉树最多拥有多少个结点？最少拥有多少个结点？,性质5,如果对一棵有n个结点的完全二叉树的结点按层序编号，则对任一结点i(1in)，有： (1) 如果i=1，则结点i是二叉树的根，无双亲；如果i1，则其双亲是i/2 (2) 如果2in，则结点i无左孩子；如果2in， 则其左孩子是2i (3) 如果2i+1n，则结点i无右孩子；如果2i+1n，则其右孩子是2i+1,性质4,二叉树的存

6、储结构 顺序存储结构 实现：按满二叉树的结点层次编号，依次存放二叉树中的数据元素 特点： 结点间关系蕴含在其存储位置中 浪费空间，适于存满二叉树和完全二叉树,链式存储结构 二叉链表,Struct bitreenode datatype data; struct bitreenode *lchild, *rchild; ,在n个结点的二叉链表中，有n+1个空指针域,三叉链表,typedef struct node datatype data; struct node *lchild, *rchild, *parent; JD;,二叉树的遍历 方法 先序遍历：先访问根结点,然后分别先序遍历左子树、

7、右子树 中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树 后序遍历：先后序遍历左、右子树，然后访问根结点 按层次遍历：从上到下、从左到右访问各结点,D L R,先序遍历序列：A B D C,先序遍历:,L D R,中序遍历序列：B D A C,中序遍历:,L R D,后序遍历序列： D B C A,后序遍历:,void preorder(JD *bt) if(bt!=NULL) printf(“%dt“,bt-data); preorder(bt-lchild); preorder(bt-rchild); ,返回,返回,返回,返回,A,C,B,D,返回,先序序列：A B D C,

8、非递归算法,i,访问：C B E G D F A,p=NULL,(15),遍历算法应用 按先序遍历序列建立二叉树的二叉链表，已知先序序列为： A B C D E G F ,求二叉树深度算法,统计二叉树中叶子结点个数算法,6.2 树的定义 定义 定义：树(tree)是n(n0)个结点的有限集T，其中： 有且仅有一个特定的结点，称为树的根(root) 当n1时，其余结点可分为m(m0)个互不相交的有限集T1,T2,Tm，其中每一个集合本身又是一棵树，称为根的子树(subtree) 特点： 树中至少有一个结点根 树中各子树是互不相交的集合,结点A的度：3 结点B的度：2 结点M的度：0,叶子：K，L

9、，F，G，M，I，J,结点A的孩子：B，C，D 结点B的孩子：E，F,结点I的双亲：D 结点L的双亲：E,结点B，C，D为兄弟 结点K，L为兄弟,树的度：3,结点A的层次：1 结点M的层次：4,树的深度：4,结点F，G为堂兄弟 结点A是结点F，G的祖先,根,子树,树的存储结构 双亲表示法 实现：定义结构数组存放树的结点，每个结点含两个域： 数据域：存放结点本身信息 双亲域：指示本结点的双亲结点在数组中位置 特点：找双亲容易，找孩子难,typedef struct node datatype data; int parent; JD; JD tM;,0,1,2,2,3,5,5,5,1,0号单元不

10、用或 存结点个数,如何找孩子结点,孩子表示法 多重链表：每个结点有多个指针域，分别指向其子树的根 结点同构：结点的指针个数相等，为树的度D 结点不同构：结点指针个数不等，为该结点的度d,孩子链表：每个结点的孩子结点用单链表存储，再用含n个元素的结构数组指向每个孩子链表,孩子结点：typedef struct node int child; /该结点在表头数组中下标 struct node *next; /指向下一孩子结点 JD; 表头结点：typedef struct tnode datatype data; /数据域 struct node *fc; /指向第一个孩子结点 TD; TD tM

11、; /t0不用,如何找双亲结点,带双亲的孩子链表,孩子兄弟表示法（二叉树表示法） 实现：用二叉链表作树的存储结构，链表中每个结点的两个指针域分别指向其第一个孩子结点和下一个兄弟结点 特点： 操作容易 但破坏了树的层次,树与二叉树转换,将树转换成二叉树 加线：在兄弟之间加一连线 抹线：对每个结点，除了其左孩子外，去除其与其余孩子之间的关系 旋转：以树的根结点为轴心，将整树顺时针转45,树转换成的二叉树其右子树一定为空,将二叉树转换成树 加线：若p结点是双亲结点的左孩子，则将p的右孩子，右孩子的右孩子，沿分支找到的所有右孩子，都与p的双亲用线连起来 抹线：抹掉原二叉树中双亲与右孩子之间的连线 调整

12、：将结点按层次排列，形成树结构,森林转换成二叉树 将各棵树分别转换成二叉树 将每棵树的根结点用线相连 以第一棵树根结点为二叉树的根，再以根结点为轴心，顺时针旋转，构成二叉树型结构,二叉树转换成森林 抹线：将二叉树中根结点与其右孩子连线，及沿右分支搜索到的所有右孩子间连线全部抹掉，使之变成孤立的二叉树 还原：将孤立的二叉树还原成树,树的遍历 遍历按一定规律走遍树的各个顶点，且使每一顶点仅被访问一次，即找一个完整而有规律的走法，以得到树中所有结点的一个线性排列 常用方法 先根（序）遍历：先访问树的根结点，然后依次先根遍历根的每棵子树 后根（序）遍历：先依次后根遍历每棵子树，然后访问根结点 按层次遍

13、历：先访问第一层上的结点，然后依次遍历第二层，第n层的结点,先序遍历：,后序遍历：,层次遍历：,A,B,E,F,I,G,C,D,H,J,K,L,N,O,M,E,I,F,G,B,C,J,K,N,O,L,M,H,D,A,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,6.3 二叉树的应用 1 霍夫曼树 路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的 路径长度：路径上的分支数 树的路径长度：从树根到每一个结点的路径长度之和 带权结点的路径长度:权值*该接点到根的路径长度 树的带权路径长度：树中所有带权结点的路径长度之和,Huffman树设有n个权值w1,w2,wn，构造一棵

14、有n个叶子结点的二叉树，每个叶子的权值为wi,则wpl最小的二叉树叫Huffman树.,例 有4个结点，权值分别为7，5，2，4，构造有4个叶子结点的二叉树,WPL=7*2+5*2+2*2+4*2=36,WPL=7*3+5*3+2*1+4*2=46,WPL=7*1+5*2+2*3+4*3=35,构造Huffman树的方法Huffman算法 构造Huffman树步骤 根据给定的n个权值w1,w2,wn，构造n棵只有根结点的二叉树，令其权值为wj 在森林中选取两棵根结点权值最小的树作左右子树，构造一棵新的二叉树，置新二叉树根结点权值为其左右子树根结点权值之和 在森林中删除这两棵树，同时将新得到的二

15、叉树加入森林中 重复上述两步，直到只含一棵树为止，这棵树即哈夫曼树,例 w=5, 29, 7, 8, 14, 23, 3, 11,Huffman算法实现,一棵有n个叶子结点的Huffman树有2n-1个结点 采用顺序存储结构一维结构数组 结点类型定义,typedef struct int data; int pa,lc,rc; ,Huffman树应用 最佳判定树,Huffman编码：数据通信用的二进制编码 思想：根据字符出现频率编码，使电文总长最短 编码：根据字符出现频率构造Huffman树，然后将树中结点引向其左孩子的分支标“0”，引向其右孩子的分支标“1”；每个字符的编码即为从根到每个叶子

16、的路径上得到的0、1序列。,例 要传输的字符集 D=C,A,S,T, ; 字符出现频率 w=2,4,2,3,3,T : 00 ; : 01 A : 10 C : 110 S : 111,译码：从Huffman树根开始，从待译码电文中逐位取码。若编码是“0”，则向左走；若编码是“1”，则向右走，一旦到达叶子结点，则译出一个字符；再重新从根出发，直到电文结束,例 电文是CAS;CAT;SAT;AT 其编码 “11010111011101000011111000011000” 电文为“1101000” 译文只能是“CAT”,2 二叉排序树 定义：二叉排序树或是一棵空树，或是具有下列性质的二叉树： 若

17、它的左子树不空，则左子树上所有结点的值均小于它的根结点的值 若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值 它的左、右子树也分别为二叉排序树,二叉排序树的插入 插入原则：若二叉排序树为空，则插入结点应为新的根结点；否则，继续在其左、右子树上查找，直至某个叶子结点的左子树或右子树为空为止，则插入结点应为该叶子结点的左孩子或右孩子 二叉排序树生成：从空树出发，经过一系列的查找、插入操作之后，可生成一棵二叉排序树,插入算法（见算法6.16）,例 10， 18， 3， 8， 12， 2， 7， 3,10,中序遍历二叉排序树可得到一个关键字的有序序列（见算法6.17）,二叉排序树的删

18、除 要删除二叉排序树中的p结点，分三种情况： p为叶子结点，只需修改p双亲f的指针f-lchild=NULL f-rchild=NULL p只有左子树或右子树 p只有左子树，用p的左孩子代替p (1)(2) p只有右子树，用p的右孩子代替p (3)(4) p左、右子树均非空 沿p左子树的根C的右子树分支找到S，S的右子树为空，将S的左子树成为S的双亲Q的右子树，用S取代p (5) 若C无右子树，用C取代p (6),删除算法,补充内容,1 二叉树与表达式求值 2 二叉树的确定 3 线索二叉树,先序遍历：,中序遍历：,后序遍历：,层次遍历：,-,+,a,*,b,-,c,d,/,e,f,-,+,a,

19、*,b,-,c,d,/,e,f,-,+,a,*,b,-,c,d,/,e,f,-,+,a,*,b,-,c,d,/,e,f,1 表达式求值与二叉树,结论： 中缀表达式可存储在二叉树中，分支结点为运算符，叶子结点为运算数，并且： 前序遍历的结果为前缀表达式； 中序遍历的结果为中缀表达式； 后序遍历的结果为后缀表达式； 所以在存储时可将分支结点用负整数标示，运算量用非负整数标示，并将具体值存放在数组中，这样在后续遍历的过程中即可求得表达式的值。即后序遍历的过程中碰到运算数标示就从数组中读出该值进栈，碰到运算符就出栈两个元素参加相关的运算，当遍历结束时栈中的值即是表达式的值。（参见图6-11）,2 二叉

20、树的确定 结论1：已知二叉树先序遍历的结果和中序遍历的结果可唯一确定一棵二叉树。 结论2：已知二叉树中序遍历的结果和后序遍历的结果可唯一确定一棵二叉树。 结论3：已知二叉树先序遍历的结果和后序遍历的结果不能唯一确定一棵二叉树。 例1：已知一棵二叉树的先序遍历和中序遍历的结果分别为ABCDEGF和CBEGDFA，试确定该二叉树。,由先序序列找到二叉树的根，再由中序序列找到根的左、右子树上的结点，依次下去得到的二叉树如右图所示。,例2： 已知二叉树的中序和后序遍历的结果分别为dbfegac和dfgebca,试确定该二叉树。,3 线索二叉树 定义： 前驱与后继：在二叉树的先序、中序或后序遍历序列中两

21、个相邻的结点互称为前驱与后继. 线索：指向前驱或后继结点的指针. 线索二叉树：加上线索的二叉链表表示的二叉树. 线索化：对二叉树按某种遍历次序使其变为线索二叉树的过程叫线索化. 实现：因在有n个结点的二叉链表中必定有n+1个空链域，故在线索二叉树的结点中增加两个标志域： lt : lt =0, lchild 域指向左孩子 lt=1, lchild域指向其前驱; rt :若 rt =0, rchild 域指向右孩子 若 rt=1, rchild域指向其后继;,Struct node char data; int lt, rt;a struct node *lc, *rc; ,结点定义：,Lc l

22、t data rt rc,1 1,0,0,0,0,1,1,1,1,1,1,中序序列：BCAED 带头结点的中序线索二叉树,头结点： lt=1 , lc指向中序遍历中的第一个结点 rt=1, rc指向遍历序列中最后一个结点 遍历序列中第一个结点的lc域和最后 一个结点的rc域都指向头结点,中序线索二叉树的实现: 带头结点的中序线索二叉树,在中序线索二叉树中找结点后继的方法： （1）若rt=1, 则rc域直接指向其后继 （2）若rt=0, 则结点的后继应是其右子树上的最左侧的结点。 在中序线索二叉树中找结点前驱的方法： （1）若lt=1, 则lc域直接指向其前驱 （2）若lt=0, 则结点的前驱应

23、是其左子树的最右侧的结点。,算法 按中序线索化二叉树,Ch5_20.c,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1

24、; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf

25、(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=

26、bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,输出:B,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD

27、 *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,1,算

28、法 按中序线索化二叉树,Ch5_20.c,输出:B,i,P-C,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr

29、-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,P-C,输出:B,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i;

30、 printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t

31、-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,1,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C,JD *zxxsh(JD *bt) JD *p,*pr,

32、*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-

33、rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr

34、-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,1,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A,P-D,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL)

35、si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A,P-D,P-E,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD);

36、 t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,

37、输出: B C A,P-D,P-E,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p

38、=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A E,P-D,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf

39、(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,1,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A E,P-D,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL

40、) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A E D,JD *zxxsh(JD *bt) JD

41、*p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-r

42、t=1; t-rc=pr; return(t); ,1,算法 按中序线索化二叉树,Ch5_20.c,i,输出: B C A E D,JD *zxxsh(JD *bt) JD *p,*pr,*sM,*t; int i=0; t=(JD *)malloc(sizeof(JD); t-lt=0; t-rt=1; t-rc=t; if(bt=NULL) t-lc=t; else t-lc=bt; pr=t; p=bt; do while(p!=NULL) si+=p; p=p-lc; if(i0) p=s-i; printf(“%c “,p-data); if(p-lc=NULL) p-lt=1; p

43、-lc=pr; if(pr-rc=NULL) pr-rt=1; pr-rc=p; pr=p; p=p-rc; while(i0|p!=NULL); pr-rc=t; pr-rt=1; t-rc=pr; return(t); ,1,算法 按中序线索化二叉树,输出: B C A E D,算法 按中序线索化二叉树 遍历中序线索二叉树,在中序线索二叉树中找结点后继的方法： （1）若rt=1, 则rc域直接指向其后继 （2）若rt=0, 则结点的后继应是其右子树的左链尾（lt=1)的结点,在中序线索二叉树中找结点前驱的方法： （1）若lt=1, 则lc域直接指向其前驱 （2）若lt=0, 则结点的前驱应是其左子树的右链尾（rt=1)的结点,