数据结构习题与解答.docx

1、数据结构习题与解答数据结构习题与解答0.1 编写冒泡排序算法，使结果从大到小排列。void BubbleSortDec ( DataType a, int n ) for ( i=0; in-1; i+ ) change = false; for( j=0; jn-i-1; j+ ) if ( ajaj+1 ) / 逆序 swap( aj, aj+1 ); change = true; if ( not change ) break; / 没有交换则完成排序 0.2 计算下面语句段中指定语句的频度： 1) for ( i=1; i=n; i+ ) for ( j=i; j=n; j+ ) x+

2、; / 2) i = 1; while ( i=n ) i = i*2; / 分析：计算语句频度是计算时间复杂度的基础。可以用观察和归纳进行简单的计算。1) 问题规模n 执行次数 1 1 2 2+1 3 3+2+1 . . n n+.+2+1=n(n+1)/2结论：语句频度为n(n+1)/2。2) 问题规模n 执行次数 1 1 2 2 3 2 4 3 . . 2k k+1结论：语句频度为。0.1 将顺序表中的元素反转顺序。void Reverse ( SqList& L ) for ( i=0; iL.length/2; i+) / 还是 =0 & L.elemix; i-) L.elemi+

3、1 = L.elemi; / 插入x (因为最后执行i-，故应在i+1处) L.elemi+1 = x; L.length+; return true;0.3 删除顺序表中所有等于x的元素。void Remove ( SqList &L, DataType x ) i = 0; / 剩余元素个数，同时是下一个元素的插入位置 for ( j=0; jL.length; j+ ) if ( L.elemj!=x ) / 复制不等于x的元素组成新表 if ( i!=j ) L.elemi = L.elemj; / 当i=j时不必复制 i+; L.length = i; / 剩余元素个数本算法的时间复

4、杂度为O(n)；若改用反复调用查找和删除算法，时间复杂度会达到O(n2)。0.4 编写算法实现顺序表元素唯一化(即使顺序表中重复的元素只保留一个)，给出算法的时间复杂度。思路：设已经唯一化的序列是(a0, , ai-1)，剩余序列是(aj, an)。所要做的就是在已经唯一化的序列L.elem0.i-1中查找L.elemj，如果未找到则复制到L.elemi处。如此重复直到剩余序列为空。void Unique ( SqList &L ) if ( L.length=1 ) return; / 空表或只有一个元素的表已经唯一化了 i = 1; / 开始L.elem0.0是唯一化序列 for ( j=

5、1; jL.length; j+ ) / 在L.elem0.i-1中查找L.elemj for ( k=0; ki; k+ ) if ( L.elemk=L.elemj ) break; if ( k=i ) / L.elemj未出现过，复制到L.elemi处 if ( j!=i ) L.elemi = L.elemj; i+; L.length = i; / 表长为i以上算法的时间复杂度为O(n2)。当然，可以反复将重复元素删除达到唯一化，时间复杂度仍是O(n2)，但是与以上算法相比要移动更多元素。0.5 非递减有序的顺序表元素唯一化(参见习题0.4)，要求算法的时间复杂度为O(n)。分析：

6、由于该表是有序的，相等的元素必然靠在一起，不必从头开始查找，所以算法的时间复杂度可以降低。思路：类似习题0.4，但是查找部分只要与L.elemi-1比较就可以了。void Unique ( SqList &L ) i = 0; / 开始的唯一化序列为空(对比习题0.4思考为什么不用i=1开始) for ( j=1; jnext; / 原链表 L-next = NULL; / 新表(空表) while ( p ) / 从原链表中取下结点s s = p; p = p-next; / 插入L新表表头 s-next = L-next; L-next = s; 0.7 采用插入法将单链表中的元素排序。v

7、oid InsertionSort ( LinkList &L ) h = L-next; / 原链表 L-next = NULL; / 新空表 while ( h ) / 从原链表中取下结点s s = h; h = h-next; / 在新表中查找插入位置 p = L; while ( p-next & p-next-datadata ) p = p-next; / 在p之后插入s s-next = p-next; p-next = s; 0.8 采用选择法将单链表中的元素排序。void SelectionSort ( LinkList &L ) p = L; while ( p-next

8、) / 选择最小(从p-next至表尾) q = p; / 最小元素的前驱q s = p; while ( s-next ) if ( s-next-data next-data ) q = s; s = s-next; m = q-next; / 找到最小m / 最小元素m插入有序序列末尾(p之后) if ( q!=p ) q-next = m-next; / 解下最小m m-next = p-next; / 插入p之后 p-next = m; p = p-next; / L-next至p为有序序列 0.9 将两个非递减有序的单链表归并成一个，仍并保持非递减有序。/ 将非递减有序的单链表lb

9、合并入la，保持非递减有序/ 结果la中含有两个链表中所有元素，lb为空表void Merge ( LinkList &la, LinkList &lb ) p = la, q = lb; while ( p-next and q-next ) / 跳过la中较小的元素 while ( p-next and (p-next-data next-data) ) p = p-next; / 把lb中较小的元素插入la中 while ( p-next and q-next and (q-next-data next-data) ) s = q-next; q-next = s-next; s-nex

10、t = p-next; p-next = s; p = s; if ( lb-next ) / 表lb剩余部分插入la末尾 p-next = lb-next; lb-next = NULL; 0.1 元素1,2,3,4依次入栈，不可能的出栈序列有哪些？分析：什么是不可能的出栈序列？如果后入栈的数(如4)先出栈，则此前入栈元素(如1,2,3)在栈中的顺序就确定了，它们的出栈顺序一定是逆序(如3,2,1)，否则就是不可能的出栈序列(如2,1,3)。不可能的出栈序列有：4123，4132，4213，4231，4312，3412，3142，3124。其中后3种都含312这一不可能序列。0.2 设循环队

11、列Q少用一个元素区分队列空和队列满，MAXSIZE=5，Q.front=Q.rear=0，画出执行下列操作时队列空和队列满的状态。入队列a,b,c，出队列a,b,c，入队列d,e,f,g。farfabrfabcrfbcrfcr f r 队列空 . frfdefgrfde 队列满。0.3 编写算法利用栈将队列中的元素翻转顺序。思路：先将队列中的元素入栈，然后从栈中取出重新入队列。void Reverse ( SqQueue &Q ) InitStack ( S ); while ( ! QueueEmpty(Q) ) DeQueue ( Q, x ); Push ( S, x ); while

12、( ! StackEmpty(S) ) Pop ( S, x ); EnQueue ( Q, x ); 0.1 长度为n的串的子串最多有多少个？思路：对子串长度归纳。子串的长度是0，1，2，.，n，对应子串的个数分别是1(空串)，n，n-1，.，1，总起来就是1+n+(n-1)+.+2+1=1+n(n+1)/2。0.1 度为k的树中有n1个度为1的结点，n2个度为2的结点，nk个度为k的结点，问该树中有多少个叶子结点。分析：分别从结点个数和分支个数考虑。设叶子个数为n0，结点总数：n = n0+n1+n2+.+nk，分支数目：n-1 = n1+2 n2+.+k nk，于是得到叶子个数 0.2

13、有n个叶子结点的完全二叉树的高度是多少?分析：完全二叉树中度为1的结点至多有一个。完全二叉树中的结点数n+(n-1) N n + (n-1) + 1，即2n-1 N 2n，二叉树的高度是 于是，(1) 当n=2k时，当没有度为1的结点时；，当有1个度为1的结点时。(2) 其他情况下，。0.3 编写算法按照缩进形式打印二叉树。void PrintBinaryTree ( BinTree bt, int indent ) if ( ! bt ) return; for ( i=0; idata ); PrintBinaryTree ( bt-lchild, indent+1 ); PrintBin

14、aryTree ( bt-rchild, indent+1 );0.4 编写算法按照逆时针旋转90度的形式打印二叉树。void PrintBinaryTree ( BinTree bt, int level ) if ( ! bt ) return; PrintBinaryTree ( bt-rchild, level+1 ); / 旋转后先打印右子树 for ( i=0; idata ); PrintBinaryTree ( bt-lchild, level+1 ); 0.5 编写算法判断二叉树是否是完全二叉树。分析：按层遍历完全二叉树，当遇到第一个空指针之后应该全都是空指针。bool Is

15、Complete ( BinTree bt ) / 按层遍历至第一个空指针 InitQueue ( Q ); EnQueue ( Q, bt ); while ( ! QueueEmpty(Q) ) DeQueue ( Q, p ); if ( p ) EnQueue ( Q, p-lchild ); EnQueue ( Q, p-rchild ); else break; / 遇到第一个空指针时停止遍历 / 检查队列中剩余元素是否全部是空指针 while ( ! QueueEmpty(Q) ) DeQueue ( Q, p ); if ( ! p ) return false; / 不是完全

16、二叉树 return true; / 完全二叉树0.6 编写算法求二叉树中给定结点的所有祖先。分析：进行后序遍历时，栈中保存的是当前结点的所有祖先。所以，后序遍历二叉树，遇到该结点时，取出栈中的内容即是所有祖先。/ 求二叉树bt中结点xptr的所有祖先vector Ancestors ( BinTree bt, BinTree xptr ) stack s; stack tag; p = bt; while ( p | ! s.empty() ) if ( p ) s.push ( p ); tag.push ( 1 ); p = p-lchild; else p = s.pop(); f =

17、 tag.pop(); if ( f=1 ) s.push ( p ); tag.push ( 2 ); p = p-rchild; else if ( p=xptr ) v = s; / 当前栈的内容就是xptr的所有祖先 return v; p = NULL; / while return vector(); / return a null vector注：这里为描述方便借助了C+中的某些描述方式。0.7 编写算法求二叉树中两个结点的最近的共同祖先。思路：用后序遍历求出两者的所有祖先，依次比较。/ 求二叉树bt中两个结点q和r的最近的共同祖先BinTree LastAncestor ( B

18、inTree bt, BinTree q, BinTree r ) stack sq, sr; stack s; stack tag; / 求q和r的所有祖先 p = bt; while ( p | ! s.empty() ) if ( p ) s.push ( p ); tag.push ( 1 ); p = p-lchild; else p = s.pop(); f = tag.pop(); if ( f=1 ) s.push ( p ); tag.push ( 2 ); p = p-rchild; else if ( p=q ) sq = s; / q的所有祖先 if ( p=r ) s

19、r = s; / s的所有祖先 p = NULL; / 先跳过不同层的祖先，然后依次比较同一层的祖先 if ( sq.size()sr.size() ) while ( sq.size()sr.size() ) sq.pop(); else while ( sr.size()sq.size() ) sr.pop(); / 求q和r的最近的共同祖先 while ( !sq.empty() and (sq.top()!=sr.top() ) /寻找共同祖先 sq.pop(); sr.pop(); if ( !sq.empty() ) return sq.top(); else return NUL

20、L;0.8 编写算法输出以二叉树表示的算术表达式（中缀形式），要求在必要的地方输出括号。分析：当左孩子的优先级低于根时需要加括号，根的优先级大于右孩子时也需要加括号。void PrintExpression ( BinTree bt ) if ( bt=NULL ) return ; if ( bt-lchild=NULL and bt-rchild=NULL ) print ( bt-data ); / 叶子结点直接打印 else / 左子树 brackets = bt-lchild and is_operator(bt-lchild-data) and comp_operator(bt-l

21、child-data, bt-data)lchild ); if ( brackets ) print (“)”); / 根结点 print ( bt-data ); / 右子树 brackets = bt-rchild and is_operator(bt-lchild-data) and comp_operator(bt-data, bt-rchild-data)0; / 根的优先级大于右孩子 if ( brackets ) print (“(“); PrintExpression ( bt-rchild ); if ( brackets ) print (“)“); 注：is_opera

22、tor(c)判断c是否是运算符；comp_operator(a,b)比较两个运算符的优先级。bool is_operator(char c) / 判断c是否是运算符 return c=+ | c=- | c=* | c=/;int comp_operator(char opl, char opr) / 比较两个运算符的优先级 return (opl=* | opl=/ | opr=+ | opr=-) ? +1 : -1;0.9 树采用孩子-兄弟链表存储，编写算法求树中叶子结点的个数。分析：树中的叶子没有孩子，即firstchild为空。/ 求树t中叶子结点的个数int LeafCount (

23、 CSTree t ) if ( t=NULL ) return 0; / 空树 if ( t-firstchild=NULL ) / 没有孩子 return 1 + LeafCount(t-nextsibling); else return LeafCount(t-firstchild) + LeafCount(t-nextsibling);0.10 采用孩子-兄弟链表存储树，编写算法求树的度。分析：度最大的结点的度数。int Degree ( CSTree t ) if ( t=NULL ) return 0; else return max( Degree(t-firstchild),

24、1+Degree(t-nextsibling);0.11 采用孩子-兄弟链表存储树，编写算法求树的深度。int Depth ( CSTree t ) if ( t=NULL ) return 0; else depchild = Depth(t-firstchild); / 孩子的深度 depsibling = Depth(t-nextsibling); / 兄弟的深度 return max(depchild+1, depsibling); / 取较大者 0.12 已知二叉树的前序和中序序列，编写算法建立该二叉树。分析：划分先序序列a=(D,(L),(R)和后序序列b=(L),D,(R)，然后

25、对子序列(L)和(R)递归。/ 根据先序序列asi.ti和中序序列bsj.tj构造二叉树BinTree CreateBinaryTree ( T a, int si, int ti, T b, int sj, int tj ) if ( nlchild = CreateBinaryTree ( a, si+1, si+k-sj, b, sj, k-1 ); / 建立左子树 p-rchild = CreateBinaryTree ( a, si+k-sj+1, b, k+1, tj); / 建立右子树 return p;0.13 树T的先根遍历序列为GFKDAIEBCHJ，后根遍历序列为DIAEKFCJHBG，