《遐想网络纯净驱动版A五章树.ppt》由会员分享，可在线阅读，更多相关《遐想网络纯净驱动版A五章树.ppt（94页珍藏版）》请在三一办公上搜索。
1、第五章 树,树是一类重要的非线性数据结构，是以分支关系定义的层次结构5.1 树的定义定义定义：树(tree)是n(n0)个结点的有限集T，其中：有且仅有一个特定的结点，称为树的根(root)当n1时，其余结点可分为m(m0)个互不相交的有限集T1,T2,Tm，其中每一个集合本身又是一棵树，称为根的子树(subtree)特点：树中至少有一个结点根树中各子树是互不相交的集合,根,子树,基本术语结点(node)表示树中的元素，包括数据项及若干指向其子树的分支结点的度(degree)结点拥有的子树数叶子(leaf)度为0的结点孩子(child)结点子树的根称为该结点的孩子双亲(parents)孩子结点
2、的上层结点叫该结点的兄弟(sibling)同一双亲的孩子树的度一棵树中最大的结点度数结点的层次(level)从根结点算起，根为第一层，它的孩子为第二层深度(depth)树中结点的最大层次数森林(forest)m(m0)棵互不相交的树的集合树中同一层各结点从左至右看成是有序的（即不能互换），则称该树为有序树，否则称为无序树。,结点A的度：3结点B的度：2结点M的度：0,叶子：K，L，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为堂兄弟
3、结点A是结点F，G的祖先,5.2 二叉树定义定义：二叉树是n(n0)个结点的有限集，它或为空树(n=0)，或由一个根结点和两棵分别称为左子树和右子树的互不相交的二叉树构成特点每个结点至多有二棵子树(即不存在度大于2的结点)二叉树的子树有左、右之分，且其次序不能任意颠倒基本形态,几种特殊形式的二叉树满二叉树定义：,特点：每一层上的结点数都是最大结点数完全二叉树定义：深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时，称为特点叶子结点只可能在层次最大的两层上出现对任一结点，若其右分支下子孙的最大层次为l，则其左分支下子孙的最大层次必为l 或l+1,
4、二叉树性质,性质2：深度为k的二叉树至多有 个结点(k1),性质3：对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1,性质4：具有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,二叉树性质性质1：,证明：用归纳法证明之 i=1时，只有一个根结点，是对的 假设对所有j(1ji)命题
5、成立，即第j层上至多有 个结点 那么，第i-1层至多有 个结点 又二叉树每个结点的度至多为2 第i层上最大结点数是第i-1层的2倍，即 故命题得证,性质2：深度为k的二叉树至多有 个结点(k1),证明：由性质1，可得深度为k 的二叉树最大结点数是,性质3：对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1,证明：n1为二叉树T中度为1的结点数 因为：二叉树中所有结点的度均小于或等于2 所以：其结点总数n=n0+n1+n2 又二叉树中，除根结点外，其余结点都只有一个 分支进入 设B为分支总数，则n=B+1 又：分支由度为1和度为2的结点射出，B=n1+2n2 于是
6、，n=B+1=n1+2n2+1=n0+n1+n2 n0=n2+1,5.3 树的存储结构树的存储结构双亲表示法实现：定义结构数组存放树的结点，每个结点含两个域：数据域：存放结点本身信息双亲域：指示本结点的双亲结点在数组中位置特点：找双亲容易，找孩子难,typedef struct node datatype data;int parent;JD;JD tM;,0,1,2,2,3,5,5,5,1,0号单元不用或存结点个数,如何找孩子结点,孩子表示法多重链表：每个结点有多个指针域，分别指向其子树的根结点同构：结点的指针个数相等，为树的度D结点不同构：结点指针个数不等，为该结点的度d,孩子链表：每个结
7、点的孩子结点用单链表存储，再用含n个元素的结构数组指向每个孩子链表,孩子结点：typedef struct node int child;/该结点在表头数组中下标 struct node*next;/指向下一孩子结点 JD;表头结点：typedef struct tnode datatype data;/数据域 struct node*fc;/指向第一个孩子结点 TD;TD tM;/t0不用,如何找双亲结点,带双亲的孩子链表,孩子兄弟表示法（二叉树表示法）实现：用二叉链表作树的存储结构，链表中每个结点的两个指针域分别指向其第一个孩子结点和下一个兄弟结点特点操作容易破坏了树的层次,typedef
8、 struct node datatype data;struct node*fch,*nsib;JD;,二叉树的存储结构顺序存储结构实现：按满二叉树的结点层次编号，依次存放二叉树中的数据元素特点：结点间关系蕴含在其存储位置中浪费空间，适于存满二叉树和完全二叉树,链式存储结构二叉链表,typedefstructBiTNodeTElemTypedata;StructBiTNode*lchild,*rchild;/左右孩子指针BiTNode,*BiTree;,在n个结点的二叉链表中，有n+1个空指针域,建立一棵二叉树,StatusCreateBiTree(BiTree/CreateBiTree,三
9、叉链表,typedef struct nodeTElemType data;struct node*lchild,*rchild,*parent;JD;,5.4 树和二叉树的遍历树的遍历遍历按一定规律走遍树的各个顶点，且使每一顶点仅被访问一次，即找一个完整而有规律的走法，以得到树中所有结点的一个线性排列常用方法先根（序）遍历：先访问树的根结点，然后依次先根遍历根的每棵子树后根（序）遍历：先依次后根遍历每棵子树，然后访问根结点按层次遍历：先访问第一层上的结点，然后依次遍历第二层，第n层的结点,先序遍历：,后序遍历：,层次遍历：,A,B,E,F,I,G,C,D,H,J,K,L,N,O,M,E,I,
10、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,二叉树的遍历方法先序遍历：先访问根结点,然后分别先序遍历左子树、右子树中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树后序遍历：先后序遍历左、右子树，然后访问根结点按层次遍历：从上到下、从左到右访问各结点,先序遍历,void PreOrderTraverse(BiTNode*Node)if(Node!=NULL)printf(%c,Node-data);PreOrderTraverse(Node-lchild);PreOrderTraverse(Node-rchild)
11、;,D L R,先序遍历序列：A B D C,先序遍历:,中序遍历,void InOrderTraverse(BiTNode*Node)if(Node!=NULL)InOrderTraverse(Node-lchild);printf(%c,Node-data);InOrderTraverse(Node-rchild);,L D R,中序遍历序列：B D A C,中序遍历:,后序遍历,void PostOrderTraverse(BiTNode*Node)if(Node!=NULL)PostOrderTraverse(Node-lchild);PostOrderTraverse(Node-rc
12、hild);printf(%c,Node-data);,L R D,后序遍历序列：D B C A,后序遍历:,先序遍历：,中序遍历：,后序遍历：,层次遍历：,-,+,a,*,b,-,c,d,/,e,f,-,+,a,*,b,-,c,d,/,e,f,-,+,a,*,b,-,c,d,/,e,f,-,+,a,*,b,-,c,d,/,e,f,编程练习,求二叉树的深度求二叉树中叶子结点的数目交换所有结点的左右子树,求二叉树的深度,int depth(BiTNode*Node)int dep1,dep2;/若T为空树，则深度为0，/否则其深度等于左子树或右子树的最大深度加1if(Node=NULL)retu
13、rn 0;else dep1=depth(Node-lchild);dep2=depth(Node-rchild);return dep1dep2?dep1+1:dep2+1;,求二叉树中叶子结点的数目,int LeafCount(BiTNode*Node)if(Node=NULL)return 0;/空树没有叶子else if(!Node-lchild/左子树的叶子数加上右子树的叶子数/LeafCount_BiTree,交换所有结点的左右子树,void Bitree_Revolute(BiTNode*Node)BiTNode*NodeTemp;NodeTemp=Node-rchild;Nod
14、e-rchild=Node-lchild;Node-lchild=NodeTemp;/交换左右子树if(Node-lchild)Bitree_Revolute(Node-lchild);if(Node-rchild)Bitree_Revolute(Node-rchild);/左右子树再分别交换各自的左右子树/Bitree_Revolute,谢 谢！,void preorder(BiTNode*bt)if(bt!=NULL)printf(%dt,bt-data);preorder(bt-lchild);preorder(bt-rchild);,返回,返回,返回,返回,A,C,B,D,返回,先序序
15、列：A B D C,1)中序遍历的非递归算法算法:Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e)InitStack(S);/置空栈 p=T;/变量P代替根结点T，起保护根的作用 while(p!StackEmpty(s)/当结点P存在或栈S不空时重复 if(p)Push(S,P);P=P-Lchild;else（P为空）Pop(s,p);/栈不空，退栈 if(!Visit(P-data)return ERROR;/若P不存在则错 P=P-rchild;/得到右孩子结点，遍历右子树/while return OK;,2)后序
16、遍历的非递归算法(S)在设计算法前，我们先分析一下后序遍历与其它遍历有何不同。从先、中序遍历过程中可以看出每个结点都只需进一次栈。但，后序遍历的过程中每个结点都必须进两次栈。第一次进栈保存是为了遍历该结点的左子树；第二次进栈保存是为了遍历该结点的右子树；只有结点第二次从栈中退出时，才能访问该结点。因而，必须设置能区分结点两次进栈的标志。设置标志的方法不是唯一的，在实际应用中一般都在栈中设置标志位B。,（A）0,A,B C,D E F,G H,I J,（D）0,（B）0,ADR B,当某结点第一次进栈时，其标志位置0，第二次进栈时，其标志位置1。当从栈中退出某结点时，同时将其标志位的值退出。然后
17、，通过判别从栈中退出的标志位的值是0、还是1，来决定是否能访问当前结点。是1，则访问该结点。是0，则再将结点进栈，同时，将标志为置1。如右图6.14D进栈后，应遍历其左子树，但D无左孩子。ADR B ADR B 此时将结点D与其标志位值0从栈中退出。经过判别不能访问，则将D再次进栈，同时把其标志位置1。然后，遍历D的右子树。后序遍历的非递归算法:,（A）0,（I）0,A,B C,D E F,G H,I J,（D）1,（G）0,（B）0,（A）0,（D）0,（B）0,图6-15后序遍历的非递归,Status PostOrderTraverse(BiTree T,Status(*Visit)(TE
18、lemType e)IniStack(S);/置空栈 p=T;/变量P代替根结点T，起保护根的作用 while(p!StackEmpty(s)/当结点P存在或栈S不空时重复 if(p)Push(S,P,B)/P存在将P进栈，B=0 P=P-Lchild;/遍历左子树 else/P为空 Pop(s,p,B);/栈不空，退栈 if(B=0)Push(S,P,B);(B=1)P=P-rchild;/遍历右子树 else if(!Visit(P-data)return ERROR;/若P不存在，则错 P=null;/while return OK;PostorderTraverse,非递归算法,Ch5
19、_4.cCh5_40.C,后序遍历非递归算法,层次遍历StatusLevelOrder(BiTreeT)/按层次遍历二叉树T，Q为队列InitQueue(Q);If(T!=NULL)/若树非空EnQueue(Q,T);/根结点入队列While(!QueueEmpty(Q)DeQueue(Q,b);/队首元素出队列Visit(b-data);/访问结点If(b-lchild!=NULL)EnQueue(Q,b-lchild);/左子树非空，则入队列If(b-rchold!=Null)EnQueue(Q,b-rchild);/右子树非空，则入队列/while/ifLevelOrder,两棵树相似,
20、若已知两棵二叉树B1和B2皆为空，或者均不为空且B1的左右子树和B2的左右子树分别相似，则称二叉树B1和B2相似。,判断两棵树是否相似的递归算法,int Bitree_Sim(Bitree B1,Bitree B2)if(!B1/Bitree_Sim,先序遍历二叉树的非递归算法,void PreOrder_Nonrecursive(Bitree T）InitStack(S);Push(S,T);/根指针进栈while(!StackEmpty(S)while(Gettop(S,p)/向右一步/while/PreOrder_Nonrecursive,求二叉树T中结点p和q的最近共同祖先,int f
21、ound=FALSE;Bitree*Find_Near_Ancient(Bitree T,Bitree p,Bitree q)Bitree pathp 100,pathq 100/设立两个辅助数组暂存从根到p,q的路径Findpath(T,p,pathp,0);found=FALSE;Findpath(T,q,pathq,0);/求从根到p,q的路径放在pathp和pathq中for(i=0;pathpi=pathqi/回溯/Findpath,判断二叉树是否完全二叉树,是则返回1,否则返回0,int IsFull_Bitree(Bitree T InitQueue(Q);flag=0;EnQu
22、eue(Q,T);/建立工作队列while(!QueueEmpty(Q)DeQueue(Q,p);if(!p)flag=1;else if(flag)return 0;elseEnQueue(Q,p-lchild);EnQueue(Q,p-rchild);/不管孩子是否为空,都入队列/whilereturn 1;/IsFull_Bitree分析:该问题可以通过层序遍历的方法来解决.与6.47相比,作了一个修改,不管当前结点是否有左右孩子,都入队列.这样当树为完全二叉树时,遍历时得到是一个连续的不包含空指针的序列.反之,则序列中会含有空指针.,遍历算法应用按先序遍历序列建立二叉树的二叉链表，已知
23、先序序列为：A B C D E G F,求二叉树深度算法,Ch5_5.cch5_6.c,Ch5_1.c,统计二叉树中叶子结点个数算法,5.5 二叉树的应用哈夫曼树(Huffman)带权路径长度最短的树定义路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的路径长度：路径上的分支数树的路径长度：从树根到每一个结点的路径长度之和树的带权路径长度：树中所有带权结点的路径长度之和,Huffman树设有n个权值w1,w2,wn，构造一棵有n个叶子结点的二叉树，每个叶子的权值为wi,则wpl最小的二叉树叫,例 有4个结点，权值分别为7，5，2，4，构造有4个叶子结点的二叉树,WPL=7*2+5*2
24、+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在森林中选取两棵根结点权值最小的树作左右子树，构造一棵新的二叉树，置新二叉树根结点权值为其左右子树根结点权值之和在森林中删除这两棵树，同时将新得到的二叉树加入森林中重复上述两步，直到只含一棵树为止，这棵树即哈夫曼树,例 w=5,29,7,8,14,23,3,11,Huffman算法实现,Ch5_8.c,一棵有n个叶子结点的Huffman
25、树有2n-1个结点采用顺序存储结构一维结构数组结点类型定义,typedef struct unsigned int weight;unsigned int parent,lchild,rchild;HTNode;/*树中结点的结构*/,typedef struct char data;/*待编码的字符*/int weight;/*字符的权值*/char codeN;/*字符的编码*/HTCode;,Ch5_8.c,Huffman树应用最佳判定树,Huffman编码：数据通信用的二进制编码思想：根据字符出现频率编码，使电文总长最短编码：根据字符出现频率构造Huffman树，然后将树中结点引向其左
26、孩子的分支标“0”，引向其右孩子的分支标“1”；每个字符的编码即为从根到每个叶子的路径上得到的0、1序列,例 要传输的字符集 D=C,A,S,T,;字符出现频率 w=2,4,2,3,3,T:00;:01A:10C:110S:111,译码：从Huffman树根开始，从待译码电文中逐位取码。若编码是“0”，则向左走；若编码是“1”，则向右走，一旦到达叶子结点，则译出一个字符；再重新从根出发，直到电文结束,例 电文是CAS;CAT;SAT;AT 其编码“11010111011101000011111000011000”电文为“1101000”译文只能是“CAT”,线索二叉树定义：前驱与后继：在二叉树
27、的先序、中序或后序遍历序列中两个相邻的结点互称为线索：指向前驱或后继结点的指针称为线索二叉树：加上线索的二叉链表表示的二叉树叫线索化：对二叉树按某种遍历次序使其变为线索二叉树的过程叫实现在有n个结点的二叉链表中必定有n+1个空链域在线索二叉树的结点中增加两个标志域lt:若 lt=0,lc 域指向左孩子；若 lt=1,lc域指向其前驱rt:若 rt=0,rc 域指向右孩子；若 rt=1,rc域指向其后继结点定义：,typedef struct node int data;int lt,rt;struct node*lc,*rc;JD;,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,
28、1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,头结点：lt=0,lc指向根结点rt=1,rc指向遍历序列中最后一个结点遍历序列中第一个结点的lc域和最后一个结点的rc域都指向头结点,算法按中序线索化二叉树,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-d
29、ata);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=bt;pr=t;p=bt;do while(p!=NULL)si+=p;p=
30、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,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;
31、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*)malloc(sizeof(JD);t-lt=0;t-rt=1;t-rc=t
32、;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,算法按中序线索化二叉树,Ch5_20.c,输出:B,i,P-C,JD*zxxsh(JD*bt)JD*p,*pr,*sM,*t;int i=0;t=
33、(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-rc=pr;return(t);,算法按中序线索化二叉树,Ch5_20.c,i,P-C,输出:B,
34、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=p-rc;while(i0|p!=NULL);pr-rc=t;pr-rt=1;t-rc=pr;re
35、turn(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-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
36、(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,*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-
37、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,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
38、-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,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 whi
39、le(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,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=
40、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,输出:B C A,P-D,P-E,JD*zxxsh(JD*bt)JD*p,*pr,*sM,*t;int
41、 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-rc=pr;return(t);,算法按中序线索化二叉树,Ch5_20.c,i,输出
42、: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(%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
43、=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)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
44、-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*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
45、=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 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+
46、=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,输出:B C A E D,算法按中序线索化二叉树遍历中序线索二叉树,Ch5_20.c,在中序线索二叉树中找结点后继的方法：（1）若rt=1,则rc域直接指向其后继（2）若rt=0,则结点的后继应是其右子树的左链尾（lt=1)的结
47、点,在中序线索二叉树中找结点前驱的方法：（1）若lt=1,则lc域直接指向其前驱（2）若lt=0,则结点的前驱应是其左子树的右链尾（rt=1)的结点,二叉排序树定义：二叉排序树或是一棵空树，或是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值它的左、右子树也分别为二叉排序树二叉排序树的插入插入原则：若二叉排序树为空，则插入结点应为新的根结点；否则，继续在其左、右子树上查找，直至某个叶子结点的左子树或右子树为空为止，则插入结点应为该叶子结点的左孩子或右孩子二叉排序树生成：从空树出发，经过一系列的查找、插入操作之后，可生成一棵二叉排序树,插入算法,例 10，18，3，8，12，2，7，3,10,中序遍历二叉排序树可得到一个关键字的有序序列,Ch5_9.c,二叉排序树的删除要删除二叉排序树中的p结点，分三种情况：p为叶子结点，只需修改p双亲f的指针f-lchild=NULL f-rchild=NULLp只有左子树或右子树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),删除算法,Ch5_10.c,
