2019数据结构考研复习指导习题代码（王道论坛）

2019数据结构考研复习指导习题代码（王道论坛）

1.从顺序表删除具有最小值的元素（假设唯一）并由函数返回被删除元素的值。空出的位置由最后一个元素补充，若顺序表为空则显示出错信息并退出运行。

bool Del_Min(Sqlist &L,ElemType &value){
//删除顺序表L中最小值元素结点，并通过引用型参数value返回其值。
 //如果删除成功，返回true;否则，返回false
 if(L.length==0)           //如果顺序表为空，则返回false
  return false;
 value=L.data[0];          //求最小值，先设第一个元素为最小的
 int pos=0;                //用pos记住最小值的下标
 for(int i=1;i<L.length;i++)
  if(L.data[i]<value){
  value=L.data[i];           //如果有比value小的元素值，则将该值赋给value
  pos=i;                    //用pos记住最小值的下标
  }
    L.data[pos]=L.data[L.length-1];      //利用pos下标
                                        //（此时下标为pos处的位置即是最小值的位置）
 L.length--;                 //长度--，直接把最后一个元素给截掉了，
// 因为最后一个元素已经赋值给pos的位置，
 //所以最后一个元素并没有丢失，所以实现了删除pos处的元素，
 //并用最后一个元素补充。
 return true;
}          

2.设计一个高效的算法，将顺序表的所有元素逆置，要求算法的空间复杂度为 o(1).

void Reverse(Sqlist &L){
     ElemType temp;            //实现思想：第一个和最后一个两两交换，
   //第二个和倒数第二个交换，以此类推
  for(i=0;i<L.length/2;i++){
           temp=L.data[i];
     L.data[i]=L.data[L.length-i-1];    
     L.data[L.length-i-1]=temp; //i的变化实现了从两边向中间推进，实现两两交换
  }
}

3.长度为n的顺序表L，编写一个时间复杂度为o(n)，空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的数据元素。

解法一：用 k 记录 L 中不等于 x 的元素个数（即需要保存的元素个数），边扫描 L 边统计 k，并将不等于 x 的元素向前放置 k 位置上，最后修改 L 的长度。
注意这里的代码是让不等于x的元素前移（把前面等于x的元素覆盖掉），利用k可以控制前移的位置，避免把已经前移的元素给覆盖了。

void del_x_l(Sqlist &L,ElemType x){
     //本算法实现删除顺序表L中所有值为x的数据元素
     int k=0;
     for(i=0;i<L.length;i++)
        if(L.data[i]!=x){
             L.data[k]=L.data[i];  //前移
             k++;                  //k的自增使其能前移到合适的位置
        }
        L.length=k;//用修改长度操作实现删除位于后面的等于x的元素
}

解法二：用 k 记录顺序表 L 中等于 x 的元素个数，边扫描 L 边统计 k，并将不等于 x 的元素前移 k 个位置，最后修改L的长度。

void del_x_2(Sqlist &L，ElemType x){
      int k=0,i=0;
      while(i<L.length){
           if(L.data[i]==x)
                  k++;            //如果元素值等于x，就只是让k自增，
                  //不等于时，自增的k用来判断前移的位置
           else
                  L.data[i-k]==L.data[i]; //如果不等于x，
           i++;
                  }
      L.length=L.length-k;
}

4.从有序表中删除其值在给定值s与t之间（要求s<t）的所有元素，如果s和t不合理，或者顺序表为空则显示出错信息并退出运行。

bool Del_s_t2(Sqlist &L，ElemType s,ElemType t){
//删除有序顺序表L中值在给定值s与t之间的所有元素
                  int i,j;
                  if(s>=t||L.length==0)  //如果s>=t或者L为空，则退出
                     return false;
                  for(i=0;i<L.length&&L.data[i]<s;i++);  //寻找>=s的第一个元素
                  if(i>=L.length)
                     return flase;       //说明没有>=s的元素，退出
                  for(j=i;j<L.length&&L.data[j]<=t;j++);  //寻找大于t的第一个元素
                  for(;j<L.length;i++,j++)
                      L.data[i]=L.data[j];     //前移覆盖s与t之间的元素
                   L.length=i+1;
                   return ture;
}

5.从顺序表中删除其值在给定值s与t之间（要求s<t）的所有元素，如果s和t不合理，或者顺序表为空则显示出错信息并退出运行。

//本题与上一题的区别是：上一题是  有序表，所以删除的元素是相连着的，而顺序表却不是这样。
bool Del_s_t(Sqlist &L,ElemType s,ElemType t){
 int i,k=0;
 if(L.length==0}}s>=t)
 return false;  //线性表为空或者s与t值不合法，则退出
 for(i=0;i<L.length;i++){
    if(L.data[i]>=s&&L.data[i]<=t)    
     k++;          //利用自增的k，记住符合条件的元素位置，方便日后删除
    else
     L.data[i-k]=L.data[i];  //当前元素前移k个位置
 }  //for
    L,length-=k;//长度减小，实现删除后面的元素
    //因为不符合删除条件的元素都在顺序表的后面
    return ture;
}

6.从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。

//注意是有序顺序表，值相同的元素一定在连续的位置上，
//用类似于直接插入排序的思想，初始时将第一个元素看作非重复的有序表。
//之后一词判断后面的元素是否与前面非重复有序表的最后一个元素相同，
//如果相同则继续向后判断，如果不同则插入到前面的非重复有序表的最后，
//直至判断到表尾为止。
bool Delete_Same(SeqList& L){
      if(L.length==0);
         return false;
      int i,j;
      for(i=0,j=1;j<L.length;j++)     //直插思想，i的初值为0， 
                                      //即把第一个元素当作有序表的第一个元素
           if(L.data[i]!=L.data[j])
              L.data[++i]=L.data[j];//如果不等于即符合不重复的条件，
                                     //就把这个元素加入有序队列，即放在i自增后的位置
      L.length=i+1;                  //因为是有序表，不用在和有序表之前的元素比较
      return true;
}

7.将两个有序顺序表合并成一个新的有序顺序表，并由函数返回结果顺序表。

bool Merge(Seqlist A,Seqlist B,Seqlist &C){
         //合并有序顺序表A与B成为一个新的有序顺序表C
         if(A.length+B.length>C.maxSize)    //大于顺序表的最大长度
         return false;
         int i=0,j=0,k=0;
         while(i<A.length&&j<B.length){//循环，两两比较，小者存入结果表C
         if(A.data[i]<=B.data[j])
           C.data[k++]=A.data[i++];
           else
           C.data[k++]=B.data[j++];
         }//while
         while(i<A.length)   //如果A剩下了，则把剩余的A全部给C
         C.data[k++]=A.data[i++];
         while(j<B.length)   //如果B剩下了，则把剩余的B全部给C
         C.data[k++]=B.data[j++];
         C.length=k+1;
         return ture;
}

8.已知在一维数组A[m+n]中依次存放着两个线性表(a1,a2,a3,…am)和(b1,b2,b3,…,bn)。试编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,…,bn)放在(a1,a2,a3,…,am)的前面。

//算法思想：首先将数组A[m+n]中的全部元素
//(a1,a2,a3,...am,b1,b2,b3,...,bn)原地逆置为
//(bn,bn-1,...,b1,am,am-1,...,a1),再对前n个元素和后m个元素
//分别使用逆置算法，就可以得到(b1,b2,b3,...,bn,a1,a2,a3,...am)
//从而实现顺序表互换
typedef int DataType;
void Reverse(DataType A[],int left, int right,int arraySize){
//逆置算法
if(left>=right||right>=arraySize)
   return false;  //违规出错
int mid=(left+right)/2
for(int i=0;i<mid-left;i++){   //第一个与最后一个交换；第二个
      DataType temp=A[left+i];   //与倒数第二个交换，以此类推
      A[left+i]=A[right-i];      //达到逆置的目的
      A[right-i]=temp;
   }
}
void Exchange(DataType A[],int m,int n,int arraySize){
  Reverse(A,0,m+n-1,arraySize);//先全体逆置
  Reverse(A,0,n-1,arraySize);  //逆置前n个，即从b1至bn
  Reverse(A,n,m+n-1,arraySize); //逆置后m个，即从a1至am
}

9.

void SearchExchangeInsert(ElemType A[],ElemType x ){
             int low=0,high=n-1,mid;
             while(low<=high){
                 mid=(low+high)/2;
                 if(A[mid]==x) break;
                 else if(A[mid]<x) low=mid+1;
                 else high=mid-1;
                 //下面两个if语句只会执行一个
                 if(A[mid]==x&&mid!=n-1){   //若最后一个元素与x相等，则不存在与其后继交换的操作
                 t=A[mid];A[mid]=A[mid+1];A[mid+1]=t;  //后继交换                                    
                 }
                 if(low>high){     //查找失败
                    for(i=n-1;i>high;i--) A[i+1]=A[i];  //i所在位置后的元素后移
                    A[i+1]=x;   //把x插入合适位置，使仍然有序
                  }
}

10.