6-1写出用广义表表示法表示的树的类声明,并给出如下成员函数的实现 (1) operator>()接收用广义表表示的树作为输入,建立广义表的存储表示; (2)复制构造函数用另一棵表示为广义表的树初始化一棵树 (3) operator==()测试用广义表表示的两棵树是否相等 (4) operator<<()用广义表的形式输出一棵树 (5)析构函数清除一棵用广义表表示的树。 【解答】 #define maxsublreeNum 20: 最大子树(子表)个数 class entree Gentre类的前视声明 ∥广义树结点类的声明 nd class entree private int urpe ∥结点标志:=0,数据;=1,子女 么0指向第一个子女 或2,指向同一层下一兄弟 ∥ape=0,根结点数据 har Childdata: aope=1,子女结点数据 Gen TreeNode firstchild ∥pe=2,指向第一个子女的指针 GenTreeNode( int p, char item ) urpe(tp), nextSibling ( NULL) i if( p==0)RootData= item; else ChildData= item;) ∥构造函数:构造广义表表示的树的数据结点 Gen TreeNode( gen TreeNode*son=NULL): urpe(2), nexiSibling(NULL) firstChild( son) ∥构造函数:构造广义表表示的树的子树结点 返回结点的数据类型 char gemara ∥返回数据结点的值 GenTreeNode GetChild oi return first Child; i 返回子树结点的地址 n TreeNode, GetNsibling){ return nextSibling;}m回下一个兄弟结点的地址 ) data= item: 1 /将结点中的值修改为iem void setFchild( GenTreeNode*p){ firsichil=pr;}/结点中的子树指针修改为pmr void setNsinbilg( GenTreeNode" ptr)( nextSibling =ptr; j class gei ∥广义树类定义 GenTreeNode *first ∥根指针 char relate: ∥建树时的停止输入标志 GenTreeNode"Copy( Gen TreeNode* ptr ) ∥复制一个p指示的子树 oid Traverse( GenListNode*ptr); ∥对p为根的子树遍历并输出
6-1 写出用广义表表示法表示的树的类声明，并给出如下成员函数的实现： (1) operator >> ( ) 接收用广义表表示的树作为输入，建立广义表的存储表示； (2) 复制构造函数 用另一棵表示为广义表的树初始化一棵树； (3) operator == ( ) 测试用广义表表示的两棵树是否相等； (4) operator #define maxSubTreeNum 20; //最大子树(子表)个数 class GenTree; //GenTree 类的前视声明 class GenTreeNode { //广义树结点类的声明 friend class GenTree; private: int utype; //结点标志：=0, 数据; =1, 子女 GenTreeNode * nextSibling; //utype=0, 指向第一个子女; //utype=1 或 2, 指向同一层下一兄弟 union { //联合 char RootData; //utype=0, 根结点数据 char Childdata; //utype=1, 子女结点数据 GenTreeNode *firstChild; //utype=2, 指向第一个子女的指针 } public: GenTreeNode ( int tp, char item ) : utype (tp), nextSibling (NULL) { if ( tp == 0 ) RootData = item; else ChildData = item; } //构造函数：构造广义表表示的树的数据结点 GenTreeNode ( GenTreeNode *son = NULL ) : utype (2), nextSibling (NULL), firstChild ( son ) { } //构造函数：构造广义表表示的树的子树结点 int nodetype ( ) { return utype; } //返回结点的数据类型 char GetData ( ) { return data; } //返回数据结点的值 GenTreeNode * GetFchild ( ) { return firstChild; } //返回子树结点的地址 GenTreeNode * GetNsibling ( ) { return nextSibling; } //返回下一个兄弟结点的地址 void setInfo ( char item ) { data = item; } //将结点中的值修改为 item void setFchild ( GenTreeNode * ptr ) { firstChild = ptr; } //将结点中的子树指针修改为 ptr void setNsinbilg ( GenTreeNode * ptr ) { nextSibling = ptr; } }; class GenTree { //广义树类定义 private: GenTreeNode *first; //根指针 char retValue; //建树时的停止输入标志 GenTreeNode *Copy ( GenTreeNode * ptr ); //复制一个 ptr 指示的子树 void Traverse ( GenListNode * ptr ); //对 ptr 为根的子树遍历并输出
void Remove( GenTreeNode "ptr )i 将以pr为根的广义树结构释放 friend int Equal( GenTreeNode*s, GenlreeNode*1); ∥比较以s和t为根的树是否相等 enTree ( ∥构造函数 ∥复制构造函数 EntRee ( ∥构函数 Entree&tl, Entree& ∥判两棵树nl与D是否相等 输入 friend ostream& operator ()接收用广义表表示的树作为输入,建立广义表的存储表示 istream& operator >> istream& in, Gen Tree& t)( ∥友元函数,从输入流对象m接受用广义表表示的树,建立广义表的存储表示L I. Constructree( in, revalue void GenTree ConstructTree( istream& in, char& value )i ∥从输入流对象m接受用广义表表示的非空树,建立广义表的存储表示t Stack st (maxSubTreeNum); ∥用于建表时记忆回退地址 cin > value: ∥广义树停止输入标志数据 整个树的根结点 cin >>ch; if( ch=="()st Push(q ) 着应是(,进栈 历逐个结点加入 switch( ch)i (q); ∥健建立子树,p-> firsIChild r->nextSibling=p; ∥插在前一结点r之后 L Push(p ) st Push( q): ∥子树结点及子树根结点进栈 >nextSibling=NULL; SLpoPO; ∥子树建成,封闭链,退到上层 ∥栈不空,取上层链子树结点 else return 0: ∥栈空,无上层链,算法结束 if( Isupper(ch)q= new GenTreenode(0,动片∥大写字母,建根结点 else q= new GenTreeNode( l, ch ) ∥非大写字母,建数据结点 >nextSibling=q: ∥链接
void Remove ( GenTreeNode *ptr ); //将以 ptr 为根的广义树结构释放 friend int Equal ( GenTreeNode *s, GenTreeNode *t ); //比较以 s 和 t 为根的树是否相等 public: GenTree ( ); //构造函数 GenTree ( GenTree& t ); //复制构造函数 ~GenTree ( ); //析构函数 friend int operator == ( GenTree& t1, GenTree& t2 ); //判两棵树 t1 与 t2 是否相等 friend istream& operator >> ( istream& in, GenTree& t ); //输入 friend ostream& operator > ( ) 接收用广义表表示的树作为输入，建立广义表的存储表示 istream& operator >> ( istream& in, GenTree& t ) { //友元函数, 从输入流对象 in 接受用广义表表示的树，建立广义表的存储表示 t。 t.ConstructTree ( in, retValue ); return in; } void GenTree :: ConstructTree ( istream& in, char& value ) { //从输入流对象 in 接受用广义表表示的非空树，建立广义表的存储表示 t。 Stack st (maxSubTreeNum); //用于建表时记忆回退地址 GenTreeNode * p, q, r; Type ch; cin >> value; //广义树停止输入标志数据 cin >> ch; first = q = new GenTreeNode ( 0, ch ); //建立整个树的根结点 cin >> ch; if ( ch == ‘(’ ) st.Push ( q ); //接着应是‘(’, 进栈 cin >> ch; while ( ch != value ) { //逐个结点加入 switch ( ch ) { case ‘(’ : p = new GenTreeNode ( q ); //建立子树, p->firstChild = q r = st.GetTop( ); st.Pop( ); //从栈中退出前一结点 r->nextSibling = p; //插在前一结点 r 之后 st.Push( p ); st.Push( q ); //子树结点及子树根结点进栈 break; case ‘)’ : q->nextSibling = NULL; st.pop( ); //子树建成, 封闭链, 退到上层 if ( st.IsEmpty ( ) == 0 ) q = st.GetTop( ); //栈不空, 取上层链子树结点 else return 0; //栈空, 无上层链, 算法结束 break; case ‘,’ : break; default : p = q; if ( isupper (ch) ) q = new GenTreeNode ( 0, ch ); //大写字母, 建根结点 else q = new GenTreeNode ( 1, ch ); //非大写字母, 建数据结点 p->nextSibling = q; //链接 }
(2)复制构造函数用另一棵表示为广义表的树初始化一棵树; GenTree : GenTree( const EntRee&r)i ∥共有函数 first= Copy ( tfirst ) GenTreeNode*GenTree: Copy GenTreeNode'ptr)( ∥私有函数,复制一个p指示的用广义表表示的子树 enTreenode*q= null; f (ptr I= NULL)t q= new GenTreeNode( pir->urpe, NULL); switch(ptr->utype) ∥根据结点类型mope传送值域 case 0:q-> Roorda=p-> rodata; break;w传送根结点数据 case:q-> Chilapa=p-> Childcare; break;传送子女结点数据 case2:q-> schild:=Copy(pr> firstChild); break;∥递归传送子树信息 g->nextSibling=Copy(ptr->nextSibling ) ∥复制同一层下一结点为头的表 (3) operator==()测试用广义表表示的两棵树是否相等 int operator==( GenTree& tl, EntRee& 2)i ∥友元函数:判两棵树n与ρ是否相等,若两表完全相等,函数返回1,否则返回0。 return Equal(tl, first, 22, first ) int Equal( Gen TreeNode * rl, GenTreeNode *2)i ∥是 Gentreenode的友元函数 f(rl==NULL&&(==NULl )return I ∥表n与表a都是空树,相等 if(nl l=NULL &&12 null & rl->urpe ==(->utype)( ∥两子树都非空且结点类型相同 switch(1l->utype)t ∥此较对应数据 case 0:x=(l-> rootdatc=12-> Rootdato)?1:0;∥根数据结点 case 1:x=(l-> Chiladata=1-> Chilapa)?1:0;∥女数据结点 e2:x=Equl(l-> firstchild,,a2-> firstchild);m递归比较其子树
cin >> ch; } } (2) 复制构造函数 用另一棵表示为广义表的树初始化一棵树； GenTree :: GenTree ( const GenTree& t ) { //共有函数 first = Copy ( t.first ); } GenTreeNode* GenTree :: Copy ( GenTreeNode *ptr ) { //私有函数，复制一个 ptr 指示的用广义表表示的子树 GenTreeNode *q = NULL; if ( ptr != NULL ) { q = new GenTreeNode ( ptr->utype, NULL ); switch ( ptr->utype ) { //根据结点类型 utype 传送值域 case 0 : q->RootData = ptr->RootData; break; //传送根结点数据 case 1 : q->ChildData = ptr->ChildData; break; //传送子女结点数据 case 2 : q->firstChild = Copy ( ptr->firstChild ); break; //递归传送子树信息 } q->nextSibling = Copy ( ptr->nextSibling ); //复制同一层下一结点为头的表 } return q; } (3) operator == ( ) 测试用广义表表示的两棵树是否相等 int operator == ( GenTree& t1, GenTree& t2 ) { //友元函数 : 判两棵树 t1 与 t2 是否相等, 若两表完全相等, 函数返回 1, 否则返回 0。 return Equal ( t1.first, t2.first ); } int Equal ( GenTreeNode *t1, GenTreeNode *t2 ) { //是 GenTreeNode 的友元函数 int x; if ( t1 == NULL && t2 == NULL ) return 1; //表 t1 与表 t2 都是空树, 相等 if ( t1 != NULL && t2 != NULL && t1->utype == t2->utype ) { //两子树都非空且结点类型相同 switch ( t1->utype ) { //比较对应数据 case 0 : x = ( t1->RootData == t2->RootData ) ? 1 : 0; //根数据结点 break; case 1 : x = ( t1->ChildData == t2->ChildData ) ? 1 : 0; //子女数据结点 break; case 2 : x = Equal ( t1->firstChild, t2->firstChild ); //递归比较其子树 }
if(x)ret ibling, 22->nextSibling ) ∥相等,递归比较同一层的下一个结点;不等,不再递归比较 (4) operatorurpe=0)out RootData nextSibling=NULL)oafirstChild); 的向子树方向搜索 if( ptr->nexzSibling = NULL)out traverse( ptr->next Sibling ) ∥向同一层下一兄弟搜索 Ise out nexzSibling: ∥在子树中删除 ptr->nextSibling=p->nexrSibling: delete(P);
if ( x ) return Equal ( t1->nextSibling, t2->nextSibling ); //相等, 递归比较同一层的下一个结点; 不等, 不再递归比较 } return 0; } (4) operator utype == 0 ) out RootData utype == 1 ) { //子女数据结点 out ChildData; if ( ptr->nextSibling != NULL ) out firstChild ); //向子树方向搜索 if ( ptr->nextSibling != NULL ) out nextSibling ); //向同一层下一兄弟搜索 } else out nextSibling; if ( p->utype == 2 ) Remove ( p->firstChild ); //在子树中删除 ptr->nextSibling = p->nextSibling; delete ( p ); //释放结点 p }
6-4用嵌套类写出用链表表示的二叉树的类声明。 【解答】 #include template class BinaryTree i template class BinTreeNode public: Bin TreeNode'lefichild,* righIChild; BintreeNode"root; BinTreeNodeParent( BinTreeNode*start, Bin TreeNode"current ) int Find( BinTreeNode *current, const Type& item )const void destroy( BinTreeNode*current ) void Traverse( Bin TreeNode*current, ostream& out )const; BinaryTree ( root( NULL) BinaryTree( Type value ) Revalue( value ) root(NULL inaryTree(i destroy (roor); 3 BinTreeNode () lefrchild( null), righIChild(NULl)0 BintreeNode ( Type item ) data( item ) lefIChild(null), righ Child(null)i Type& GetData(const( return data: j BinTreeNode" GetLefi( const( return lefiChild: 3 BintreeNode* GetRight(const return righIChild; j void SetData( const Type& item i data= item; 3 void SetRight( BinTreeNode"R RighChild=R;) int ls Empty (i return root==NULL? 1: 0; 3 Bin TreeNode*Parent( BinTreeNode*current i return root== NULL I root== current? NULL Parent(root, current );) BinTreeNode* Lefichild( BintreeNode *current) return current I= NULL? current->lefi child: NULL ode* Right Child( Bin TreeNode*current) return current I= NULL currenr->right Child: NULL int Insert( const Type& item )i BinTreeNode* Find( const Type& item )i Type>*GetRoot()const( return roof; j friend istream& operator >> istream& in, BinaryTree& Tree ) 输入二叉树 friend ostream& operator & Tree ) 输出二叉树
} 6-4 用嵌套类写出用链表表示的二叉树的类声明。 【解答】 #include template class BinaryTree { private: template class BinTreeNode { public: BinTreeNode *leftChild, *rightChild; Type data; } Type RefValue; BinTreeNode * root; BinTreeNode *Parent ( BinTreeNode *start, BinTreeNode *current ); int Insert ( BinTreeNode *current, const Type& item ); int Find ( BinTreeNode *current, const Type& item ) const; void destroy ( BinTreeNode *current); void Traverse ( BinTreeNode *current, ostream& out ) const; public: BinaryTree ( ) : root( NULL ) { } BinaryTree ( Type value ) : RefValue ( value ), root ( NULL ){ } ~BinaryTree ( ) { destroy (root);} BinTreeNode ( ) : leftChild ( NULL ), rightChild ( NULL ) { } BinTreeNode ( Type item ) : data ( item ), leftChild ( NULL ), rightChild ( NULL ) {} Type& GetData ( ) const { return data; } BinTreeNode* GetLeft ( ) const{ return leftChild; } BinTreeNode* GetRight ( ) const { return rightChild; } void SetData ( const Type& item ){ data = item; } void SetLeft ( BinTreeNode *L ) { leftChild = L; } void SetRight ( BinTreeNode *R ){ RightChild =R; } int IsEmpty ( ) { return root == NULL ? 1 : 0; } BinTreeNode *Parent ( BinTreeNode *current ) { return root== NULL || root== current ? NULL : Parent ( root, current ); } BinTreeNode * LeftChild ( BinTreeNode *current ) { return current != NULL ? current->leftChild : NULL;} BinTreeNode * RighttChild ( BinTreeNode *current ) { return current != NULL ? current->rightChild : NULL;} int Insert ( const Type& item ); BinTreeNode * Find ( const Type& item ); BinTreeNode * GetRoot ( ) const{ return root; } friend istream& operator >> ( istream& in, BinaryTree& Tree ); //输入二叉树 friend ostream& operator & Tree ); //输出二叉树
6-5在结点个数为n(m>1)的各棵树中,高度最小的树的高度是多少?它有多少个叶结点?多少个分支结 点?高度最大的树的高度是多少?它有多少个叶结点?多少个分支结点? 【解答】结点个数为n时,高度最小的树的高度为1,有2层;它有n1个叶结点,1个分支结点;高度 最大的树的高度为n1,有n层;它有1个叶结点,n1个分支结点 6-7如果一棵树有m个度为1的结点,有m2个度为2的结点,…,m个度为m的结点,试问有多少个度 为0的结点?试推导之。 【解答】总结点数n=m+n+n+…+mm 总分支数e=m1=m+n1+n2+…+nm-1 测有m) 6-8试分别找出满足以下条件的所有二叉树 (1)二叉树的前序序列与中序序列相同 (2)二叉树的中序序列与后序序列相同 (3)二叉树的前序序列与后序序列相同 【解答】 (1)二叉树的前序序列与中序序列相同:空树或缺左子树的单支树 (2)二叉树的中序序列与后序序列相同:空树或缺右子树的单支树 (3)二叉树的前序序列与后序序列相同:空树或只有根结点的二叉树 6-9若用二叉链表作为二叉树的存储表示,试针对以下问题编写递归算法: (1)统计二叉树中叶结点的个数 (2)以二叉树为参数,交换每个结点的左子女和右子女。 【解答】 (1)统计二叉树中叶结点个数 int BinaryTree: leaf( BinTreeNode*ptr)t if(ptr== NULL)return 0; nid==NULL) else return leaf( ptr->lefiChild)+leaf(ptr- Child (2)交换每个结点的左子女和右子女 void BinaryTree: exchange( BinTreeNode*ptr)i BinTreeNodex’my; if(pir->lefiChild 1= NULL II ptr->righ Child I=NULL)( ptr->lefiChild= ptr->right Child exchange(ptr->lefichild ) exchange( ptr->righI Child);
} 6-5 在结点个数为 n (n>1)的各棵树中，高度最小的树的高度是多少？它有多少个叶结点？多少个分支结 点？高度最大的树的高度是多少？它有多少个叶结点？多少个分支结点？ 【解答】结点个数为 n 时，高度最小的树的高度为 1，有 2 层；它有 n-1 个叶结点，1 个分支结点；高度 最大的树的高度为 n-1，有 n 层；它有 1 个叶结点，n-1 个分支结点。 6-7 如果一棵树有 n1 个度为 1 的结点, 有 n2 个度为 2 的结点, … , nm 个度为 m 的结点, 试问有多少个度 为 0 的结点? 试推导之。 【解答】总结点数 n = n0 + n1 + n2 + … + nm 总分支数 e = n-1 = n0 + n1 + n2 + … + nm-1 = m*nm + (m-1)*nm-1 + … + 2*n2 + n1 则有 ( 1) 1 2 0 + = − = m i ni n i 6-8 试分别找出满足以下条件的所有二叉树: (1) 二叉树的前序序列与中序序列相同; (2) 二叉树的中序序列与后序序列相同; (3) 二叉树的前序序列与后序序列相同。 【解答】 (1) 二叉树的前序序列与中序序列相同：空树或缺左子树的单支树； (2) 二叉树的中序序列与后序序列相同：空树或缺右子树的单支树； (3) 二叉树的前序序列与后序序列相同：空树或只有根结点的二叉树。 6-9 若用二叉链表作为二叉树的存储表示，试针对以下问题编写递归算法： (1) 统计二叉树中叶结点的个数。 (2) 以二叉树为参数，交换每个结点的左子女和右子女。 【解答】 (1) 统计二叉树中叶结点个数 int BinaryTree :: leaf ( BinTreeNode * ptr ) { if ( ptr == NULL ) return 0; else if ( ptr->leftChild == NULL && ptr->rightChild == NULL ) return 1; else return leaf ( ptr->leftChild ) + leaf ( ptr->rightChild ); } (2) 交换每个结点的左子女和右子女 void BinaryTree :: exchange ( BinTreeNode * ptr ) { BinTreeNode * temp; if ( ptr->leftChild != NULL || ptr->rightChild != NULL ) { temp = ptr->leftChild; ptr->leftChild = ptr->rightChild; ptr->rightChild = temp; exchange ( ptr->leftChild ); exchange ( ptr->rightChild );
6-10一棵高度为h的满k叉树有如下性质:第h层上的结点都是叶结点,其余各层上每个结点都有k棵 非空子树,如果按层次自顶向下,同一层自左向右,顺序从1开始对全部结点进行编号,试问 (1)各层的结点个数是多少? (2)编号为i的结点的父结点(若存在)的编号是多少? (3)编号为i的结点的第m个孩子结点(若存在)的编号是多少? (4)编号为i的结点有右兄弟的条件是什么?其右兄弟结点的编号是多少? 【解答】 (1)k(i=0,1,……,h) i+k-2 k (3)(-1)*k+m+1 (4)(-1)modk≠0或i≤ i+k-2 hk时有右兄弟,右兄弟为/+1 6-11试用判定树的方法给出在中序线索化二叉树上 【解答】 (1)搜索指定结点的在中序下的后继。 设指针q指示中序线索化二叉树中的指定结点,指针p指示其后继结点 g->righThread=1? g->righiChild== NULL? q的后继为q的右子树中 中序下的第一个结点 q无后继 q的后继为q-> righIChild 找q的右子树中在中序下的第一个结点的程序为: while(p-> leftThread a=1)p=p-> lefiChild;∥p即为q的后继 (2)搜索指定结点的在前序下的后继 g->leftThread ==0? q的后继为q-> lefichild q的后继为q-> righIChild P= while(p->right Thread== 1&& p->righ/ Child != NULl)P=p->righIChild; if(p-> rightchild==NLL)q无后继; (3)搜索指定结点的在后序下的后继 q无后继 p->rightThread== I >rightchild q的后继为p q的后继为p的右子树中后序下的第一个结点
} } 6-10 一棵高度为 h 的满 k 叉树有如下性质: 第 h 层上的结点都是叶结点, 其余各层上每个结点都有 k 棵 非空子树, 如果按层次自顶向下, 同一层自左向右, 顺序从 1 开始对全部结点进行编号, 试问: (1) 各层的结点个数是多少? (2) 编号为 i 的结点的父结点(若存在)的编号是多少? (3) 编号为 i 的结点的第 m 个孩子结点(若存在)的编号是多少? (4) 编号为 i 的结点有右兄弟的条件是什么? 其右兄弟结点的编号是多少? 【解答】 (1) k i ( i = 0, 1, ……, h ) (2) i k k + − 2 (3) ( i-1)*k + m + 1 (4) ( i-1 ) mod k 0 或 i + − i k k k 2 * 时有右兄弟，右兄弟为 i + 1。 6-11 试用判定树的方法给出在中序线索化二叉树上： 【解答】 (1) 搜索指定结点的在中序下的后继。 设指针 q 指示中序线索化二叉树中的指定结点，指针 p 指示其后继结点。 找 q 的右子树中在中序下的第一个结点的程序为： p = q->rightChild; while ( p->leftThread == 1 ) p = p->leftChild; // p 即为 q 的后继 (2) 搜索指定结点的在前序下的后继。 (3) 搜索指定结点的在后序下的后继。 q->rightThread == 1? = ≠ q->rightChild == NULL ? = q 无后继 ≠ q 的后继为 q->rightChild q 的后继为 q 的右子树中 中序下的第一个结点 q->leftThread == 0 ? = q的后继为 q->leftChild ≠ q->rightThread == 0 ? = q 的后继为 q->rightChild ≠ p = q; while ( p->rightThread == 1 && p->rightChild != NULL ) p = p->rightChild; if ( p->rightChild ==NULL ) q 无后继; else 的后继为 p->rightChild ( p = parent (q ) ) == NULL ? = q 的后继为 p ≠ p->rightThread == 1 || p->rightChild == q ?= ≠ q 的后继为 p 的右子树中后序下的第一个结点 q 无后继
可用一段遍历程序来实现寻找p的右子树中后序下的第一个结点:即该子树第一个找到的叶结点。 找到后立即返回它的地址 6-12已知一棵完全二叉树存放于一个一维数组Tl]中,T中存放的是各结点的值。试设计一个算法 从T0开始顺序读出各结点的值,建立该二叉树的二叉链表表示 【解答】 建立二叉树 istream& operator >> istream& in, BinaryTree&1)i int n: cout >n Type A= new Type nm+1]: for int i=0; i>A0: ee( T, n, 0, ptr )i ∥以数组建立一棵二叉树 delete [A return in: template void BinaryTree: ConstructTree(Type T[I, int n, int i, Bin TreeNode*& ptr)t ∥有函数:将用Tn]顺序存储的完全二叉树,以i为根的子树转换成为用二叉链表表示的 以p为根的完全二叉树。利用引用型参数pr将形参的值带回实参 ∥建立根结点 ConstructTree(T, n, 2 i+1, ptr->lefiChild); ConstructUre(T,n,2·汁2,p-> righichild); 6-14写出向堆中加入数据4,2,5,8,3,6,10,14时,每加入一个数据后堆的变化。 【解答】以最小堆为例: 6-16请画出右图所示的树所对应的二叉树
可用一段遍历程序来实现寻找 p 的右子树中后序下的第一个结点：即该子树第一个找到的叶结点。 找到后立即返回它的地址。 6-12 已知一棵完全二叉树存放于一个一维数组 T[n]中，T[n]中存放的是各结点的值。试设计一个算法， 从 T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 【解答】 template //建立二叉树 istream& operator >> ( istream& in, BinaryTree& t ) { int n; cout > n; Type *A = new Type[n+1]; for ( int i = 0; i > A[i]; t. ConstructTree( T, n, 0, ptr ); //以数组建立一棵二叉树 delete [ ] A; return in; } template void BinaryTree :: ConstructTree ( Type T[ ], int n, int i, BinTreeNode *& ptr ) { //私有函数 : 将用 T[n]顺序存储的完全二叉树, 以 i 为根的子树转换成为用二叉链表表示的 //以 ptr 为根的完全二叉树。利用引用型参数 ptr 将形参的值带回实参。 if ( i >= n ) ptr = NULL; else { ptr = new BinTreeNode ( T[i] ); //建立根结点 ConstructTree ( T, n, 2*i+1, ptr->leftChild ); ConstructTree ( T, n, 2*i+2, ptr->rightChild ); } } 6-14 写出向堆中加入数据 4, 2, 5, 8, 3, 6, 10, 14 时，每加入一个数据后堆的变化。 【解答】以最小堆为例： 6-16 请画出右图所示的树所对应的二叉树。 4 4 2 4 4 4 2 2 5 5 5 2 2 8 8 4 3 5 2 8 3 4 5 2 8 3 4 6 5 2 8 3 4 6 10 5 2 8 3 4 6 10 14
【解答】 对应二叉树 6-17在森林的二叉树表示中,用lmk存储指向结点第一个子女的指针,用rink存储指向结点下一个兄 弟的指针,用daa存储结点的值。如果我们采用静态二叉链表作为森林的存储表示,同时按森林的先根 次序依次安放森林的所有结点,则可以在它们的结点中用只有一个二进位的标志lag代替link,用nag 代替rink。并设定若lag=0,则该结点没有子女,若lag≠0,则该结点有子女;若rg=0,则该结点 没有下一个兄弟,若nag≠0,则该结点有下一个兄弟。试给出这种表示的结构定义,并设计一个算法 将用这种表示存储的森林转换成用link- rlink表示的森林 【解答】 对应二叉树 2345678910 G 森林的左子女-右兄弟 rlink[ 2 表示的静态二叉链表 0123 5678910 ataABCdE 森林的双标记表示 (1)结构定义 template class LchRsibNode{∥左子女-右兄弟链表结点类的定义 protected Type da ∥结点数据 ∥结点的左子女、右兄弟指针 LchRsibNode (: llinkNULL), rlink(NULL) LchRsibNode( type x ): link(NULL), rlink(NULl), data(x)3 template class Doubly Tag Node{W双标记表结点类的定义 protecte Type data ∥结点数据
【解答】 6-17 在森林的二叉树表示中，用 llink 存储指向结点第一个子女的指针，用 rlink 存储指向结点下一个兄 弟的指针，用 data 存储结点的值。如果我们采用静态二叉链表作为森林的存储表示，同时按森林的先根 次序依次安放森林的所有结点，则可以在它们的结点中用只有一个二进位的标志 ltag 代替 llink，用 rtag 代替 rlink。并设定若 ltag = 0，则该结点没有子女，若 ltag 0，则该结点有子女；若 rtag = 0，则该结点 没有下一个兄弟，若 rtag 0，则该结点有下一个兄弟。试给出这种表示的结构定义，并设计一个算法， 将用这种表示存储的森林转换成用 llink - rlink 表示的森林。 【解答】 (1) 结构定义 template class LchRsibNode { //左子女-右兄弟链表结点类的定义 protected: Type data; //结点数据 int llink, rlink; //结点的左子女、右兄弟指针 public: LchRsibNode ( ) : llink(NULL), rlink(NULL) { } LchRsibNode ( Type x ) : llink(NULL), rlink(NULL), data(x) { } } template class DoublyTagNode { //双标记表结点类的定义 protected: Type data; //结点数据 1 对应二叉树 1 2 2 3 3 4 4 5 5 6 6 7 8 8 7 A B C D E F G H K I J A B C D E F G H I K J 对应二叉树 llink data rlink 0 1 2 3 4 5 6 7 8 9 10 1 -1 -1 4 -1 6 -1 8 9 -1 -1 A B C D E F G H I K J 5 2 3 -1 -1 7 -1 -1 10 -1 -1 森林的左子女-右兄弟 表示的静态二叉链表 ltag data rtag 0 1 2 3 4 5 6 7 8 9 10 1 0 0 1 0 1 0 1 1 0 0 A B C D E F G H I K J 1 1 1 0 0 1 0 0 1 0 0 森林的双标记表示
int ltag, rtag; ∥结点的左子女、右兄弟标记 lyTag Node ( ltag(o), rtag(0) Doubly Tag Node( Type x): ltag(o), rtag(o), data(x)U template class staticlinkList 静态链表类定义 public LchRsibNode*U; ∥储双标记表的向量 int MaxIe, Currentsice: ∥向量中最大元素个数和当前元素个数 dstaticlinkList( int Maxs= ) MaxSie( Maxsz ) CurrentSize(0)t V=new LchRsibNode [Maxs:] U=new Doubly Tag Node [Maxs:]: (2)森林的双标记先根次序表示向左子女-右兄弟链表先根次序表示的转换 void staticlinkLisK: DtagF-tchRsibFOi Stacking> >st: int k: for int i=0; i<CurrentSize; i++)i switch(U(lag)& case0: switch(U0rtag )( if (st IsEmpty(=0) ik=st GetTop(: st Pop(: Mk]. rlink=i+ 1;) case 1: vO llink =-I: i rlink =i+ I; break; case 1: switch(U[rtag )( case0: VO llink =i+ 1: v. rlink=-1; break case 1: v. llink =i+ 1; st Push(i); 6-18二叉树的双序遍历( Double -order traversa)是指:对于二叉树的每一个结点来说,先访问这个结点 再按双序遍历它的左子树,然后再一次访问这个结点,接下来按双序遍历它的右子树。试写出执行这种 双序遍历的算法
int ltag, rtag; //结点的左子女、右兄弟标记 public: DoublyTagNode ( ) : ltag(0), rtag(0) { } DoublyTagNode ( Type x ) : ltag(0), rtag(0), data(x) { } } template class staticlinkList //静态链表类定义 : public LchRsibNode, public DoublyTagNode { private: LchRsibNode *V; //存储左子女-右兄弟链表的向量 DoublyTagNode *U; //存储双标记表的向量 int MaxSize, CurrentSize; //向量中最大元素个数和当前元素个数 public: dstaticlinkList ( int Maxsz ) : MaxSize ( Maxsz ), CurrentSize (0) { V = new LchRsibNode [Maxsz]; U = new DoublyTagNode [Maxsz]; } } (2) 森林的双标记先根次序表示向左子女-右兄弟链表先根次序表示的转换 void staticlinkList :: DtagF-LchRsibF ( ) { Stack st; int k; for ( int i = 0; i < CurrentSize; i++ ) { switch ( U[i].ltag ) { case 0 : switch ( U[i].rtag ) { case 0 : V[i].llink = V[i].rlink = -1; if ( st.IsEmpty ( ) == 0 ) { k = st.GetTop ( ); st.Pop ( ); V[k].rlink = i + 1; } break; case 1 : V[i].llink = -1; V[i].rlink = i + 1; break; } break; case 1 : switch ( U[i].rtag ) { case 0 : V[i].llink = i + 1; V[i].rlink = -1; break; case 1 : V[i].llink = i + 1; st.Push ( i ); } } } } 6-18 二叉树的双序遍历(Double-order traversal)是指：对于二叉树的每一个结点来说，先访问这个结点， 再按双序遍历它的左子树，然后再一次访问这个结点，接下来按双序遍历它的右子树。试写出执行这种 双序遍历的算法