【2022王道考研数据结构综合习题】线性表 顺序表

线性表 顺序表

1.删除最小元素并末尾元素填补

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

bool Del_Min(Sqlist L,ElemType &value){
if(L.length<=0)
  return false;
value=L.date[0];
int pos=0;
for(int i=0;i<L.length;i++){
  if(L.date[i]<L.date[0]){
      value=L.date[i];
      pos=i;}
L.date[pos]=L.date[length-1];
L.length--;
return true;}

2.顺序表逆置

设计一个高效算法，将顺序表L的所有元素逆置，时间复杂度为O（1）

void reserve(Sqlist &L){
int temp;
for(int i=0;i<(L.length)/2;i++){
  temp=L.date[L.length-i-1];
  L.date[L.length-i-1]=L.date[i];
  L.date[i]=temp;}}

3.删除所有值为x的数据元素

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

解法一：用k记录等于x的个数

void del_x_1(Sqlist &L,Elemtype x){
for(int i=0;i<L.length;i++){
  if(L.date[i]==x) k++;
  else L.date[i-k]=L.date[i];}
L.length=L.length-k;
}

解法二：用k记录不等于x的个数

void del_x_2(Sqlist &L,Elemtype x){
int k=0;
for(int i=0;i<L.length;i++){
  if(L.date[i]!=x){
    L.date[k]=L.date[i];
    k++;}
L.length=l;
}

4.删除开区间内元素🌟

从有序表中删除其值在定制s与t之间（要求s<t)的所有元素，若s,t不合理或顺序表为空，则显示出错信息并退出运行。

bool Del_s_t2(Sqlist &l,Elemtype s,Elemtype t){
int i,j;
if(L.length<=0)
  return false;
for(i=0;i<L.length&&L.date[i]<s;i++);//寻找值大于等于s的第一个元素
if(i>=L.length) return false;
fot(j=i;j<L.length&&L.date[j]<=t;j++);//寻找值大于t的第一个元素
for(;j<L.length;i++,j++)
  L.date[i]=L.date[j];
L.length=i;
return true;
}

5.删除闭区间内元素（类比3.）

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

bool Del_s_t(Sqlist &L,Elemtype s,Elemtype t){
if(L.length<=0||s>t) return false;
for(int i=0;i<L.length;i++){
  if(L.date[i]>=s&&L.date[i]<=t) k++;
  else L.date[i-k]=L.date[i];
  }
L.length-=k;
return true;
}

6.删除重复元素 （类似直接排序的思想）

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

bool Delete_Same(Sqlist &L){
if(L.length<=0) return false;
int i,j;//i存吃第一个不相同的元素，j为工作指针
for(i=0,j=0;i<L.length;i++,j++){
  if(L.date[i]!=L.date[j] 
    L.date[++i]==L.date[j];
L.length==i+1;
return true;

7.合并有序列表🌟

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

bool Merge(Sqlist A,Sqlist B,Squlist &C){
if(A.length+B.length>C.maxSize) return false;
int i=0,j=0,k=0;
while(i<A.length&&i<B.length){
  if(A.date[i]<=B.date[i])
    C.date[k++]=A.date[i++];
  else
    C.date[k++]=B.date[j++];
    }
while(i<A.length)
  C.date[k++]=A.date[i++];
while(i<B.length)
  C.date[k++]=B.date[j++];
C.length=k;
return true;

8.两个线性表互换位置

已知在一位数组A[m+n]中依次存放两个线性表（a1,an) (b1,bn)试着编写一个函数，将数组中两个顺序表的位置互换，即将（b1,bn)放在(a1,an)

typedef int DateType;
void Reserve (DateType A[],int left,int right,int arraysize){
if(left>=right||right>=arraysize)
  return;
int mid=(left+right)/2;
for(int i=0;i<mid;i++){
  Datetype temp=A[left+1];
  A[left+i]=A[right-i];
  A[right-i]=temp;}
  }
//调用
void Exchange (Datetype A[],int m,int n,int arraysize){
Reserve(A,0,m+n-1,arraysize);
Reserve(A,0,n-1,arraysize);
Reserve(A,n,m+n-1,arraysize);

9.查找，交换，插入元素（折半查找）

线性表（a1,an) 中的元素递增有序且按顺序存储与于计算机中，要求设计一个算法，完成用时最少在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍递增有序。

void SearchExhangeInsert(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(A[mid]==x&&mid!=n-1){
  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];
  A[i+1]=x;
  }
}

10. 逆转函数（类似8）

void Reserve(int R[],int from,int to){
  int temp;
  for(int i=0;i<(to-form+1)/2;i++){
    temp=R[from+i];
    R[form+i]=R[to-i];
    R[to-i]=temp;
    }
void Converse(int R[],int n,int p){
Reserve(R,0,p-1);
Reserve(R,p,n-1);
Reserve(R,0,n-1);

11.两升序列中位数(二分思想）

int M_search(int A[],int B[],int n){
  int s1=0,d1=n-1,m1;
  int s2=0,d2=n-1,m2;//分别表示首位数，末位数，中位数
  while(s1!=d1||s2!=d2){
    m1=(s1+d1)/2;
    m2=(s2+d2)/2;
    if(A[m1]==B[m2])
      return A[m1];
    if(A[m1]<B[m2]){
      if((s1+d1)%2==0){
        s1=m1;
        d2=m2;
        }
      else{
        s1=m1+1;
        d2=m2;
        }
    }
    if(A[m1]>B[m2]){
      if((s1+d1)%2==0){
        s1=m1;
        d2=m2;
        }
      else{
        s1=m1;
        d2=m2+1;
        }
    }
  }
 return A[s1]<B[s2]?A[s1]:B[s2];
 }
 
 

12.寻找主元素

int Majority(int A[],int n){
  int c,count=1;
  c=A[0];
  for(int i=1;i<n;i++){
    if(A[i]==c) count++;
    else 
      if(count>0)
        count--;
      else{
        c=A[i];
        count=1;
      }
    if(count>0)
      for(i=count=0;i<n;i++)
        if(A[i]==c)
           count++;
    if(count>n/2) return c;
    else return -1;
    }
    

13.找数组中未出现的最小整数

int findMissMin(int A[],int n){
  int *B;
  B=new int[n];
  memset(B,0,n);
  for(int i=0;i<n;i++){
    if(A[i]>0&&A[i]<=n)
      B[A[i]-1]=1;}
  for(int i=0;i<n;i++){
    if(B[i]==0) break;}
  return i+1;
  }

14.三元数组中的最小距离

#define INT_MAX 0x7fffffff
//计算绝对值
int abs_(int a){
  if(a<0) return -a;
  else return a;
//a是否是三个数中最小值
bool xls_min(int a,int b,int c){
  if(a<=b&&a<=c) return true;
  return flase;
//计算最小距离
int findMinofTrip(int A[],int n,int B[],int m,int C[],int p){
  int D_min=INT_MAX,D;
  while(i<n&&j<m&&k<p&&D_MIN>0){
    D=abs_(A[i]-B[j])+abs_(B[j]-C[k])+abs_(C[k]-A[i]);
    if(D<D_min) D_min=D;
    if(xls_min(A[i],B[j],C[k])) i++;
    else if (xls_min(B[j],C[k],A[i])) j++;
    else k++;
  }
  return D_min;
}