遐想网络纯净驱动版A五章树

第五章第五章 树树      树是一类重要的非线性数据结构，是以分支关系定义的层次结构l5.1 树的定义l定义l定义：树(tree)是n(n>0)个结点的有限集T，其中：§有且仅有一个特定的结点，称为树的根(root)§当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2,……Tm，其中每一个集合本身又是一棵树，称为根的子树(subtree)l特点：§树中至少有一个结点——根§树中各子树是互不相交的集合A只有根结点的树ABCDEFGHIJKLM有子树的树根子树l基本术语l结点(node)——表示树中的元素，包括数据项及若干指向其子树的分支l结点的度(degree)——结点拥有的子树数l叶子(leaf)——度为0的结点l孩子(child)——结点子树的根称为该结点的孩子l双亲(parents)——孩子结点的上层结点叫该结点的~l兄弟(sibling)——同一双亲的孩子l树的度——一棵树中最大的结点度数l结点的层次(level)——从根结点算起，根为第一层，它的孩子为第二层……l深度(depth)——树中结点的最大层次数l森林(forest)——m(m0)棵互不相交的树的集合l树中同一层各结点从左至右看成是有序的（即不能互换），则称该树为有序树，否则称为无序树。

ABCDEFGHIJKLM结点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为堂兄弟结点A是结点F，G的祖先l5.2 二叉树l定义l定义：二叉树是n(n0)个结点的有限集，它或为空树(n=0)，或由一个根结点和两棵分别称为左子树和右子树的互不相交的二叉树构成l特点§每个结点至多有二棵子树(即不存在度大于2的结点)§二叉树的子树有左、右之分，且其次序不能任意颠倒l基本形态A只有根结点的二叉树空二叉树AB右子树为空AB左子树为空ABC左、右子树均非空l几种特殊形式的二叉树l满二叉树§定义：§特点：每一层上的结点数都是最大结点数l完全二叉树§定义：深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时，称为~§特点§叶子结点只可能在层次最大的两层上出现§对任一结点，若其右分支下子孙的最大层次为l，则其左分支下子孙的最大层次必为l 或l+11231145891213671014151231145891267101234567123456二叉树性质性质2：深度为k的二叉树至多有                 个结点(k1)性质3：对任何一棵二叉树T，如果其终端结点数为n0，  度为2的结点数为n2，则n0=n2+1性质4：具有n个结点的完全二叉树的深度为§性质5：如果对一棵有n个结点的完全二叉树的结点按层序编号，则对任一结点i(1in)，有：  (1)  如果i=1，则结点i是二叉树的根，无双亲；如果i>1，则其双亲是i/2  (2)  如果2i>n，则结点i无左孩子；如果2in，则其左孩子是2i  (3)  如果2i+1>n，则结点i无右孩子；如果2i+1n，则其右孩子是2i+1l二叉树性质l性质1：证明：用归纳法证明之 i=1时，只有一个根结点， 是对的 假设对所有j(1j

scanf(&ch);if (ch=='＃') T=NULL;else {    if (!(T=(BiTNode *) malloc(sizeof(BiTNode))))  exit (OVERFLOW);    T->data = ch;              //生成根结点    CreateBiTree(T->lchild);   //生成左子树    CreateBiTree(T->rchild);   //生成右子树}return OK;}//CreateBiTree§三叉链表typedef struct node{TElemType data; struct node *lchild, *rchild, *parent;}JD;lchild data parent rchildABCDEFG A B C D E F G^^^^^^^^^l5.4 树和二叉树的遍历l树的遍历l遍历——按一定规律走遍树的各个顶点，且使每一顶点仅被访问一次，即找一个完整而有规律的走法，以得到树中所有结点的一个线性排列l常用方法§先根（序）遍历：先访问树的根结点，然后依次先根遍历根的每棵子树§后根（序）遍历：先依次后根遍历每棵子树，然后访问根结点§按层次遍历：先访问第一层上的结点，然后依次遍历第二层，……第n层的结点ABCDEFGHIJKLMNO先序遍历：后序遍历：层次遍历：ABE F I GCDHJ KL NOME I F G B C J K N O L M H D AAB C DE F GH I J KL MNOl二叉树的遍历l方法§先序遍历：先访问根结点,然后分别先序遍历左子树、右子树§中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树§后序遍历：先后序遍历左、右子树，然后访问根结点§按层次遍历：从上到下、从左到右访问各结点DLRLDR、LRD、DLRRDL、RLD、DRL先序遍历void PreOrderTraverse(BiTNode *Node){if(Node!=NULL){printf("%c",Node->data);PreOrderTraverse(Node->lchild);PreOrderTraverse(Node->rchild);}}ADBCD L RAD L RD L R>B>>D>>CD L R先序遍历序列：A B D C先序遍历:中序遍历void InOrderTraverse(BiTNode *Node){if(Node!=NULL){InOrderTraverse(Node->lchild);printf("%c",Node->data);InOrderTraverse(Node->rchild);}}ADBCL D RBL D RL D R>A>>D>>CL D R中序遍历序列：B D A C中序遍历:后序遍历void PostOrderTraverse(BiTNode *Node){if(Node!=NULL){PostOrderTraverse(Node->lchild);PostOrderTraverse(Node->rchild);printf("%c",Node->data);}}ADBC L R DL R DL R D>A>>D>>CL R D后序遍历序列： D B C A后序遍历:B-+/a*b-efcd先序遍历：中序遍历：后序遍历：层次遍历：- + a * b - c d / e f-+a*b-cd/ef- +a *b - c d/e f-+a*b-c d/e f编程练习编程练习l求二叉树的深度l求二叉树中叶子结点的数目l交换所有结点的左右子树求二叉树的深度求二叉树的深度int depth(BiTNode *Node){int dep1,dep2;//若T为空树，则深度为0，//否则其深度等于左子树或右子树的最大深度加1if(Node==NULL) return 0;else {  dep1=depth(Node->lchild);  dep2=depth(Node->rchild);  return dep1>dep2?dep1+1:dep2+1;  }}求二叉树中叶子结点的数目求二叉树中叶子结点的数目int LeafCount(BiTNode *Node){   if(Node==NULL) return 0; //空树没有叶子else if(!Node->lchild&&!Node->rchild) return 1; //叶子结点else return LeafCount(Node->lchild)+LeafCount(Node->rchild);    //左子树的叶子数加上右子树的叶子数}//LeafCount_BiTree 交换所有结点的左右子树交换所有结点的左右子树void Bitree_Revolute(BiTNode *Node){ BiTNode *NodeTemp;NodeTemp=Node->rchild;Node->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("%d\t",bt->data); preorder(bt->lchild); preorder(bt->rchild); }}主程序主程序Pre( T )返回返回pre(T R);返回返回pre(T R);ACBDTBprintf(B);pre(T L);BTAprintf(A);pre(T L);ATDprintf(D);pre(T L);DTCprintf(C);pre(T L);C返回T>左是空返回pre(T R);T>左是空返回T>右是空返回T>左是空返回T>右是空返回pre(T R);先序序列：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;l}2)后序遍历的非递归算法 (S)在设计算法前，我们先分析一下后序遍历与其它遍历有何不同。

从先、中序遍历过程中可以看出每个结点都只需进一次栈但，后序遍历的过程中每个结点都必须进两次栈第一次进栈保存是为了遍历该结点的左子树；第二次进栈保存是为了遍历该结点的右子树；只有结点第二次从栈中退出时，才能访问该结点因而，必须设置能区分结点两次进栈的标志设置标志的方法不是唯一的，在实际应用中一般都在栈中设置标志位B （A） 0 A B C D E F G H I J（D） 0（B） 0ADR B当某结点第一次进栈时，其标志位置0，第二次进栈时，其标志位置1当从栈中退出某结点时，同时将其标志位的值退出然后，通过判别从栈中退出的标志位的值是0、还是1，来决定是否能访问当前结点是1，则访问该结点是0，则再将结点进栈，同时，将标志为置1如右图6.14D进栈后，应遍历其左子树，但D无左孩子          ADR         B                    ADR         B                                此时将结点D与其标志位值0从栈中退出。

经过判别不能访问，则将D再次进栈，同时把其标志位置1然后，遍历D的右子树l后序遍历的非递归算法: （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)(TElemType 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§非递归算法ABCDEFGpiP->A(1)ABCDEFGpiP->AP->B(2)ABCDEFGpiP->AP->BP->C(3)p=NULLABCDEFGiP->AP->B访问：C(4)pABCDEFGiP->A访问：C B(5)ABCDEFGiP->AP->D访问：C Bp(6)ABCDEFGiP->AP->DP->E访问：C Bp(7)ABCDEFGiP->AP->D访问：C B Ep(8)ABCDEFGiP->AP->DP->G访问：C B EP=NULL(9)ABCDEFGiP->A访问：C B E G Dp(11)ABCDEFGiP->AP->F访问：C B E G Dp(12)ABCDEFGiP->AP->D访问：C B E Gp(10)ABCDEFGiP->A访问：C B E G D Fp=NULL(13)ABCDEFGi访问：C B E G D F Ap(14)ABCDEFGi访问：C B E G D F Ap=NULL(15)Ch5_4.cCh5_40.C后序遍历非递归算法l层次遍历lStatus LevelOrder(BiTree T){  //按层次遍历二叉树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  }//if}LevelOrder两棵树相似两棵树相似l若已知两棵二叉树B1和B2皆为空，或者均不为空且B1的左右子树和B2的左右子树分别相似，则称二叉树B1和B2相似。

判断两棵树是否相似的递归算法判断两棵树是否相似的递归算法lint Bitree_Sim(Bitree B1,Bitree B2)l{  if(!B1&&!B2) return 1;  else if(B1&&B2&&Bitree_Sim(B1->lchild,B2->lchild)&&Bitree_Sim(B1->rchild,B2->rchild))    return 1;  else return 0;}//Bitree_Sim 先序遍历二叉树的非递归算法先序遍历二叉树的非递归算法lvoid PreOrder_Nonrecursive(Bitree T） {  InitStack(S);  Push(S,T); //根指针进栈  while(!StackEmpty(S))  {    while(Gettop(S,p)&&p)    {      visit(p->data);      push(S,p->lchild);    } //向左走到尽头    pop(S,p);    if(!StackEmpty(S))    {     pop(S,p);     push(S,p->rchild); //向右一步    }  }//while}//PreOrder_Nonrecursive 求二叉树求二叉树T中结点中结点p和和q的最近共同祖先的最近共同祖先lint found=FALSE; lBitree* 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;pathp[i]==pathq[i]&&pathp[i];i++); //查找两条路径上最后一个相同结点  return pathp[--i];}//Find_Near_Ancient lvoid Findpath(Bitree T,Bitree p,Bitree path[ ],int i)//求从T到p路径的递归算法{  if(T==p)  {    found=TRUE;    return; //找到  }  path[i]=T; //当前结点存入路径  if(T->lchild) Findpath(T->lchild,p,path,i+1); //在左子树中继续寻找  if(T->rchild&&!found) Findpath(T->rchild,p,path,i+1); //在右子树中继续寻找  if(!found) path[i]=NULL; //回溯}//Findpath 判断二叉树是否完全二叉树判断二叉树是否完全二叉树,是则返回是则返回1,否则返否则返回回0lint IsFull_Bitree(Bitree T {  InitQueue(Q);  flag=0;  EnQueue(Q,T); //建立工作队列  while(!QueueEmpty(Q))  {    DeQueue(Q,p);    if(!p) flag=1;    else if(flag) return 0;    else    {      EnQueue(Q,p->lchild);      EnQueue(Q,p->rchild); //不管孩子是否为空,都入队列    }  }//while  return 1;}//IsFull_Bitree分析:该问题可以通过层序遍历的方法来解决.与6.47相比,作了一个修改,不管当前结点是否有左右孩子,都入队列.这样当树为完全二叉树时,遍历时得到是一个连续的不包含空指针的序列.反之,则序列中会含有空指针. l遍历算法应用§按先序遍历序列建立二叉树的二叉链表，已知先序序列为：    A  B  C      D  E    G      F      §求二叉树深度算法Ch5_5.cch5_6.cABCDEFG A ^ B ^ C ^ D ^ E ^ F ^ ^ G ^Ch5_1.c§统计二叉树中叶子结点个数算法l5.5 二叉树的应用l哈夫曼树(Huffman)——带权路径长度最短的树l定义§路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的~§路径长度：路径上的分支数§树的路径长度：从树根到每一个结点的路径长度之和§树的带权路径长度：树中所有带权结点的路径长度之和§Huffman树——设有n个权值{w1,w2,……wn}，构造一棵有n个叶子结点的二叉树，每个叶子的权值为wi,则wpl最小的二叉树叫~例 有4个结点，权值分别为7，5，2，4，构造有4个叶子结点的二叉树abcd7524WPL=7*2+5*2+2*2+4*2=36dcab2475WPL=7*3+5*3+2*1+4*2=46abcd7524WPL=7*1+5*2+2*3+4*3=35l构造Huffman树的方法——Huffman算法§构造Huffman树步骤§根据给定的n个权值{w1,w2,……wn}，构造n棵只有根结点的二叉树，令起权值为wj§在森林中选取两棵根结点权值最小的树作左右子树，构造一棵新的二叉树，置新二叉树根结点权值为其左右子树根结点权值之和§在森林中删除这两棵树，同时将新得到的二叉树加入森林中§重复上述两步，直到只含一棵树为止，这棵树即哈夫曼树例a7b5c2d4a7b5c2d46a7b5c2d4611a7b5c2d461118例 w={5, 29, 7, 8, 14, 23, 3, 11}51429 7823 3111429 7823 1135887151429233581111358191429238715113581929 23148715292914871529113581923421135819234229148715295811358192342291487152958100§Huffman算法实现Ch5_8.c§一棵有n个叶子结点的Huffman树有2n-1个结点§采用顺序存储结构——一维结构数组§结点类型定义typedef struct{ unsigned int weight; unsigned int parent,lchild,rchild; }HTNode; /*树中结点的结构*/typedef struct { char data; /*待编码的字符*/ int weight; /*字符的权值 */ char code[N]; /*字符的编码 */} HTCode;lc data rc pa1 2 3 4 5 6 70 0 0 0 0 0 07 5 2 4 0 0 00 0 0 0 0 0 00 0 0 0 0 0 0(1)lc data rc pa1 2 3 4 5 6 70 0 0 0 3 0 07 5 2 4 6 0 00 0 0 0 4 0 00 0 5 5 0 0 0kx1=3,x2=4m1=2,m2=4(2)lc data rc pa1 2 3 4 5 6 70 0 0 0 3 2 07 5 2 4 6 11 00 0 0 0 4 5 00 6 5 5 6 0 0kx1=2,x2=5m1=5,m2=6(3)lc data rc pa1 2 3 4 5 6 70 0 0 0 3 2 17 5 2 4 6 11 180 0 0 0 4 5 67 6 5 5 6 7 0kx1=1,x2=6m1=7,m2=11(4)Ch5_8.clHuffman树应用§最佳判定树等级分数段比例ABCDE0~5960~6970~79 80~89 90~1000.050.150.400.300.10a<60a<90a<80a<70EYNDYNCYNBYNA70a<80a<60CYNBYNDYNEYNA80a<9060a<70EADECa<80a<70a<60a<90EYNDYNCYNBYNA§Huffman编码：数据通信用的二进制编码§思想：根据字符出现频率编码，使电文总长最短§编码：根据字符出现频率构造Huffman树，然后将树中结点引向其左孩子的分支标“0”，引向其右孩子的分支标“1”；每个字符的编码即为从根到每个叶子的路径上得到的0、1序列例 要传输的字符集 D={C,A,S,T, ; } 字符出现频率 w={2,4,2,3,3}CS3364224814T;A00110110T : 00; : 01A : 10C : 110S : 111§译码：从Huffman树根开始，从待译码电文中逐位取码。

若编码是“0”，则向左走；若编码是“1”，则向右走，一旦到达叶子结点，则译出一个字符；再重新从根出发，直到电文结束例 电文是{CAS;CAT;SAT;AT} 其编码 “11010111011101000011111000011000” 电文为“1101000” 译文只能是“CAT”CS3364224814T;A00110110T : 00; : 01A : 10C : 110S : 111l线索二叉树l定义：§前驱与后继：在二叉树的先序、中序或后序遍历序列中两个相邻的结点互称为~§线索：指向前驱或后继结点的指针称为~§线索二叉树：加上线索的二叉链表表示的二叉树叫~§线索化：对二叉树按某种遍历次序使其变为线索二叉树的过程叫~l实现§在有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; lc lt data rt rcABCDE A B D C ET先序序列：ABCDE先序线索二叉树00001111 ^11ABCDE A B D C ET中序序列：BCAED中序线索二叉树00001111^11^ABCDE A B D C ET后序序列：CBEDA后序线索二叉树0000111111^ABCDE 0 A 0 1 B 0 0 D 1 1 C 1 1 E 1 T中序序列：BCAED带头结点的中序线索二叉树 0 1头结点：lt=0, lc指向根结点rt=1, rc指向遍历序列中最后一个结点遍历序列中第一个结点的lc域和最后一个结点的rc域都指向头结点 A B D C ET中序序列：BCAED中序线索二叉树00001111^11^l算法§按中序线索化二叉树Ch5_20.cABCDEt 0 1prpiP->AJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);} A B D C Ebt^^^^^^0000000000l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^^^t 0 1prpiP->AP->BJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000000000l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^^^t 0 1prP=NULLiP->AP->BJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000000000l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^^^t 0 1prPiP->A输出:BJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}00000000001l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^^t 0 1prP输出:BiP->AP->CJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000100000l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^^t 0 1prP=NULLiP->AP->C输出:BJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000100000l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^^t 0 1prPiP->A输出: B C JD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}00001000001l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^t 0 1prP=NULLiP->A输出: B C JD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000100010l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^^t 0 1prPi输出: B C A JD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}00001000101l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^t 0 1Pi输出: B C A prP->DJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000101010l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^t 0 1Pi输出: B C A prP->DP->EJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000101010l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^t 0 1P=NULLi输出: B C A prP->DP->EJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000101010l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^^t 0 1Pi输出: B C A E prP->DJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000101010 1l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^t 0 1P=NULLi输出: B C A E prP->DJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}0000101011l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^^t 0 1Pi输出: B C A E D prJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}00001010111l算法§按中序线索化二叉树Ch5_20.cABCDE A B D C Ebt^t 0 1P=NULLi输出: B C A E D prJD *zxxsh(JD *bt){ JD *p,*pr,*s[M],*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){ s[i++]=p; p=p->lc; } if(i>0) { 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(i>0||p!=NULL); pr->rc=t; pr->rt=1; t->rc=pr; } return(t);}00001011111l算法§按中序线索化二叉树Ch5_20.cABCDE输出: B C A E D A B D C Et 0 11111110000l算法§按中序线索化二叉树§遍历中序线索二叉树Ch5_20.c在中序线索二叉树中找结点后继的方法：（1）若rt=1, 则rc域直接指向其后继（2）若rt=0, 则结点的后继应是其右子树的左链尾（lt=1)的结点在中序线索二叉树中找结点前驱的方法：（1）若lt=1, 则lc域直接指向其前驱（2）若lt=0, 则结点的前驱应是其左子树的右链尾（rt=1)的结点ABCDE 0 A 0 1 B 0 0 D 1 1 C 1 1 E 1 T中序序列：BCAED带头结点的中序线索二叉树 0 1l二叉排序树l定义：二叉排序树或是一棵空树，或是具有下列性质的二叉树：§若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值§若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值§它的左、右子树也分别为二叉排序树l二叉排序树的插入§插入原则：若二叉排序树为空，则插入结点应为新的根结点；否则，继续在其左、右子树上查找，直至某个叶子结点的左子树或右子树为空为止，则插入结点应为该叶子结点的左孩子或右孩子§二叉排序树生成：从空树出发，经过一系列的查找、插入操作之后，可生成一棵二叉排序树§插入算法例 {10， 18， 3， 8， 12， 2， 7， 3}10101810183101838101838 12101838 122101838 1227101838 12273中序遍历二叉排序树可得到一个关键字的有序序列Ch5_9.cl二叉排序树的删除要删除二叉排序树中的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)SQPLP中序遍历：Q S PL PSQPL中序遍历：Q S PL(2)SPPLQ中序遍历：PL P S QSPLQ中序遍历：PL S Q(1)中序遍历：P PR S QSPRQ中序遍历：PR S Q(3)SPPRQ中序遍历：Q S P PRSQPR中序遍历：Q S PR(4)SQPRPFPCPRCLLSSL中序遍历：CL C ……QL Q SL S P PR FFSCPRCLLSL中序遍历：CL C ……QL Q SL S PR F(5)FPCPRCL中序遍历：CL C P PR FFCPRCL中序遍历：CL C PR F(6)§删除算法例805012060110150557053删除508060120110150557053删除60805512011015053701042581354删除1084255134删除58425413Ch5_10.c。