【真题】杭电851数据结构历年算法设计题

杭电851数据结构

19年算法设计题

1. 求出指定结点在给定二叉排序树中的层次

   int findLevel(BiTree T,int x){
       int level = 0;
       BiTree bt;
       bt = T;
       while(bt!=NULL){
           n++;
           while(bt->data != data){
               if(bt->data <x)
                   bt = bt->rlchild;
               else
                   bt = bt->lchild;
               n++;
           }
       }
       return n;
   }

---

---

2. 给定一个二叉树和其中的一个结点。请找出中序遍历顺序中该结点的下一个结点并且返回。注意，树中的结点。不仅包含左右子结点，同时包含指向父结点的指针。

   //节点结构如下:
   struct TreeLinkNode{
       int val;
       struct TreeLinkNode *left;
       struct TreeLinkNode *right;
       struct TreeLinkNode *next;
       TreeLinkNode(int x):val(int x)，left(NULL),right(NULL),next(NULL){}
   };
   /*
   算法思想：
    题目要求查找某结点的中序序列的后继，可分为以下两种情况：
    ① 当该结点有右孩子时，则其后继结点就是其右孩子分支上的最左边的结点;
    ② 当该结点没有右孩子时，此时又分为两种情况:
     	a.如果该结点是父结点的左子结点，则其后继结点就是其父结点。
	b.如果该结点是父结点的右子结点，则需要不断往上找其父亲结点，
	直到找到一个满足这样条件的结点——该结点父结点的右孩子不再是其自身，
	换句话就是该结点是其父结点的左孩子时，那么后继结点就是这个父亲结点。
   */
   //代码如下
   TreeLinkNode* GetNext(TreeLinkNode* pNode){
       TreeLinkNode bt = pNode;
       //第一种情况
       if(bt->right!=NULL){
            bt = bt->right;
           while(bt->left!=NULL)
               bt = bt->left;
           return bt;
       }
       
       //第二种情况的a
       if(bt->next!=NULL && bt->next.left == bt)
       {
           return bt->next;
       }
       
        //第二种情况的b
       if(bt->next != NULL){
           while(bt->next != NULL && bt->next->riht == bt)
               bt = bt->next;
       }
       return bt->next;
   }

---

---

3. 编写算法，实现在单向链表上删除具有重复值的多余节点，使得表中每个节点的数值均保持不同。

   /*
   以下代码是在有序单链表上删除重复值，
   无序的情况较复杂，不赘述。
   */
   
   /*
   由于单链表有序，因此只需要依次遍历相邻两个结点的值是否相同即可。
   */
   void Del_Same(LinkList &L){
       LNode *p = L->next;
       LNode *q;
       if(p==NULL)
           return;
       while(p->next!=NULL){
           q = p->next;
           if(p->next==q->next){
               p->next = q->next;
               free(q);
           }
           else
               p = p->next;
       }
   }

---

---

4. 假设一个算数表达式中包括圆括号()，方括号[]，和花括号{}，编写一个算法来判别表达式中的括号是否配对，以字符'作为算数表达式的结束符。

   //此处只给出匹配圆括号()时的代码，
   //方括号[]，和花括号{}同理
   
   bool Match(char *str){
       int i=0,flag=0;
       InitStack(S);
       char e;
       while(str[i]!=''){
           switch(str[i]){
               case '(':
                   Push(S,str[i]);
               	break;
               case ')':{
                   Pop(S,&e);
                   if(e!='(')
                       flag =1;
               	}
              		break;
   			default:
                  	break;
           }//switch结束
           if(flag)
               break;
           i++
       }//while结束
       if(!flag && StackEmpty(S)){
           printf("匹配成功");
           return true;
       }
       else{
   		printf("匹配失败");
           return false;
       }
   }

---

---

5. 请设计计算法MatToList，将无向图的邻接矩阵转为对应的邻接表。

//已知图的邻接矩阵的存储结构说明为:
Typedef Sturct{
  int vertex[m];
  int edge[m];
}gadmatrix;

//图的邻接表的存储结构说明为:
Typedef Sturct node1{
  int info;
  int adjvertex;
  struct node1 *nextarc;
}glinklistnode;

Typedef Sturct node2{
  int vertexinto;
  glinklistnode *firstarc;
}glinkheadnode;

//以下为代码
void MatToList(gadjmatrix g1[],glinkheadnode g2[]){
  int i,j,glinklistnode *p;
  for(i=0;i<n;i++)
      g2[i].firstarc =0;
  for(i=0;i<n;i++)  
      for(j=0;j<n;i++)
          if(g1.edge[i][j]==1){
              p = (glinklistnode*)malloc(sizeof(glinklistnode));
              p->adjvertex = j;
              p->nextarc = g1[i].firstarc;
              g1[i].firstarc =p;
              
              p = (glinklistnode*)malloc(sizeof(glinklistnode));
              p->adjvertex = i;
              p->nextarc = g1[j].firstarc;
              g1[j].firstarc =p;
          }
}


//除此以外，邻接表转换为邻接矩阵的代码为:
void Convert(ALGraph &G,int arc[M][N]){
  for(i=0;i<n;i++){
      p = (G->v[i]).firstarc;
      while(p!=NULL){
          arc[i][p->data] =1;
          p = p->nextarc;
      }
  }
}

---

---

6. 在n个元素中，找出第k大的元素，用C语言写出数据结构，设计算法实现上述要求，并分析时间复杂性，最好是平均时间复杂性为O(n）。

   int Kth_elem(int a[],int low.int high,int k){
       int key = a[low];
    int low_temp = low;
       int high_temp = high; 
       //经典的快排模板
       while(low<high){
           while(low<high && a[high]>=key)
               high--;
           a[low] = a[high];
           while(low<high && a[low]<=key)
               low++;
           a[high] = a[low];
       }
       a[low] = key;
       if(low == k)
           return a[low];
       else if(low >k)
           return Kth_elem(a,low_temp.low-1,k);
       else
           return Kth_elem(a,low+1,high_temp,k-low);
   }