学习 严蔚敏讲数据结构笔记18

遍历是所有非线性结构（包括二叉树，树，图和广义表）的操作基础

不同的应用需要应用不同的搜索路径

1.      深度优先搜索遍历 2广度优先搜索遍历

深度优先搜索遍历：

二叉树先序，中序，后序

树     先根，后根

图     先访问顶点，后访问顶点

广义表先遍历表头，先遍历表尾

深度优先搜索遍历算法的两种形式：递归，非递归

6.12已知L[i]和R[i](i=1,2,…n-1)分别指示二叉树中第i个结点的左孩子和右孩子结点，0表示空。试写判别结点u是否是结点v的子孙的算法。

分析：

1.      u是否是结点v的子孙===从结点v出发遍历能否到达结点u；“访问”===判结点u是否是结点v的孩子

2.      给出的存储结构实质上是一个二叉链表

32_002

Status descendent(int L[], int R[], int  u,int v) {          if(u  && v)          {                    if(L[v]  == u || R[v] == u)                             return  TRUE;                    else  if(descendent(L, R, u, L[v]))                             return  TRUE;                    else                              return  descendent(L, R, u, R[v]);          }          else  return FALSE; }

 

6.19 编写递归算法：对于二叉树中每一个元素值为x的结点，删去以它为根的子树，并释放相应的空间。

分析：

1.      先序遍历二叉树的过程中查找每一个元素值为x的结点；

2.      修改其双亲结点的相应指针；

3.      释放以它为艮的子树上的所有结点，则应该后序遍历以它为根的子树

32_003

void Delete-X(BiTree &BT, ElemType x) {          if(BT)          {                    if(BT->data  == x)                    {                             disp(BT);                             BT  = NULL;                    }                    else                    {                             Delete-X(BT->Lchild,  x);                             Delete-X(BT->Rchild,  x);                    }          } }

6.22 编写一个算法：输出以二叉树表示的算数表达式，若该表达式中含有括号，则输出时应添上

分析：

1.      原表达式即为带括弧的中缀表达式，则此题应该进行中序遍历

2.      表达式求值应该进行后序遍历，则表明左、右子树的运算应该先于根结点的运算进行；因此，若左、右子树根的运算符的优先数低于根节点运算符的优先数，则应对左子树和右子树应加上括弧；

32_004

void Expression(BiTree T) {          if(T)          {                    if(precede(T->data,  T->Lchild->data)                    {                             printf("(");                             Expression(T->Lchild);                             printf(")");                    }                    else                             Expression(T->Lchild);                    printf(T->data);                    if(precede(T->data,  T->Lchild->data))          } }

6.24 编写算法完成下列操作：无重复地输出以孩子兄弟链表存储的树T中所有的边。输出的形式为(k1,k2),…,(ki,kj),..,其中，ki和kj为树结点中的结点标识。

分析：

在孩子兄弟链表中，哪一些结点是根的孩子？

33_001

void OutEdge(CStree T) {          if(T)          {                    p  = T->firstchild;                    while(p)                    {                             prntf(T->data,  p->data);                             OutEdge(p);                             p  = p->nextsibling;                    }          } }//先根遍历输出树中各条边

7.7 已知有向图和图中两个顶点u和v，试编写算法求有向图从u到v的所有简单路径。

33_002

void DFSearch(Graph G, int v, int s) {          visited[v]  = TRUE; //访问第v个顶点          Append(PATH,  getVertex(v));          for(w  = FirstAdjVex(v); w != 0; w = NextAdjVex(v))                    OutPath(PATH);          if(!  visited[w])                    DFSearch(G,  w, s);          visited[v]  = FLASE; }

深度优先搜索遍历的非递归形式的算法：一般情况下，需要一个“栈”保留一些信息

例如：遍历二叉树时，需要利用栈保留曾经路过的根结点（中序）；或者保留尚未遍历的右子树的根结点（先序）以便从左子树返回时继续遍历右子树。

后序遍历二叉树的情况要复杂一些，由于根结点的访问在左、右子树的遍历之后，则不仅要保存结点的信息，还应保存“标志”。

反之，如果在存储结构中加上适当的信息，

 

6.15假设在二叉链表的结点中增设两个域；双亲域（parent）以指示其双亲结点；标识域（mark：0，1，2）以区分在遍历过程中到达该节点时应继续向左或向右访问该结点，试以此存储结构编写不用栈进行后序遍历的递归形式的算法。

Mark域的作用在于识别当前的状态：

Mark=0表示当前状态是对结点第一次访问

Mark=1表示当前状态是对结点第二次访问

Mark=2表示当前状态是对结点第三次访问

33_003

void postorder(BiTree T) {          p  = T;          while(p)          {                    switch(p->mark)                    {                    case  0:                             p->mark  = 1;                             if(p->Lchild)                             {                                      p  = p->Lchild;                             }                             break;                    case  1:                             p->mark  = 2;                             if(p->Rchild)                             {                                      p  = p->Rchild;                             }                             break;                    case  2:                             p->mark  = 0;                             //...                    }          } }

深度优先遍历图的非递归形式的算法

33_004

void DFS(Graph G, int v) {          visited[v]  = TRUE;          VisitFunc(v);          for(w  = FirstAdjVex(G, v); w != 0; w = NextAdjVex(G, v, w))                    if(!  visited[w])                             DFS(G,  w); }

可见，栈中保留的信息应该是：当前访问的顶点和它当前的邻接点

33_005

void DFS(Graph g, int v) {          Visit(v);          visited[v]  = TRUE;          ...          while(!  StackEmpty(S))          {                    v  = GetTop(S).vp;                    w  = GetTop(S),wp;                    if(w)                    {                             if(!  visited[w])                             {                                      Visit(w);                                      visited[w]  = TRUE;                                      ...                             }                             else                             {                                      w  = NextAdj(G, v, w);                                      ...                             }                             Pop(S);                    }            } }

广度优先搜索遍历的算法

33_006

void BFSTraverse(Graph G, Status(*  Visit)(int v)) {          for(v  = 0; v < G.vexnum; ++ v)                    visited[v]  = FALSE;          InitQueue(Q);  //置空的辅助队列Q          for(v  = 0; v < G.vexnum; ++v)          {                    if(!  visited[v])                    {                             //v尚未访问                             visited[v]  = TRUE;                             Visit(v);  //访问v                             EnQueue(Q,  v); //v入队列                             while(!  QueueEmpty(Q))                             {                                      DeQueue(Q,  u); //队列元素出队并置为u                                      for(w  = FirstAdjVex(G, u); w != 0; w = NextAdjVex(G, u, w))                                                if(!  visited[w])                                                {                                                         visited[w]  = TRUE;                                                         Visit(w);                                                         Enqueue(Q,  w); //                                                }                             }                    }          } }

6.20编写按层次顺序（同一层自左至右）遍历二叉树的算法

33_007

void BFSTraverse(BiTree T) {          InitQueue(Q);  //置空的辅助队列Q          if(T)                    EnQueue(Q,  T); //根结点入队列          while(!  QueueEmpty(Q))          {                    DeQueue(Q,  p); //队头元素出队并置为p                    Visit(p);                    if(p->Lchild)                             EnQueue(Q,  p->Lchild); //左子树根入队列                    if(p->Rchild)                             EnQueue(Q,  p->Rchild); //右子树根入队列          } }

33_008

void BFSTraverse(CSTree T) {          InitQueue(Q);  //置空的辅助队列Q          if(T)                    EnQueue(Q,  T); //根结点入队列          while(!  QueueEmpty(Q))          {                    DeQueue(Q,  p); //队头元素出队并置为p                    Visit(p);                    for(q  = p->firstchild; !q; q = q->nextsibling)                             EnQueue(Q,  q); //子树根入队列          } }