线性表的顺序表示习题

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

bool Del_Min(SqList &L,int &value){
    //删除顺序表L中最小元素的结点，并通过引用型参数value返回其值
    //删除成功返回true
    if(L.length==0) return false;
    value=L.data[0];
    int pos=o;//下标
    for(int i=1;i<L.length;i++)
      if(L.data[i]<value){
        value=L.data[i];
        pos=i;}
    L.data[pos]=L.data[L.Length-1];
    L.length--;
    return true;
        
}

 

设计一个高效的算法，将顺序表的所有元素逆置，要求复杂度O（1）
void Reverse(Sqlist %L){
    int 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; 
    }
} 

 

长度为n的顺序表L，编写一个时间复杂度O（n），空间复杂度O(1),删除线性表中所有值为x的数据元素
void del_x_l(Sqlist &L,int x){
    int k=0;  //记录不等于x的元素个数
    for(int i=0;i<L.length;i++)
        if(L.data[i]!=x){
            L.data[k]=L.data[i];//留下 
            k++;
        }
    L.length=l;
    
    
} 

 

从有序顺序表中删除其值为定值s与t之间（包含st，要求是s<t）的所有元素，如果s t不合理或顺序表为空则显示错误信息并返回
bool Del_s_t(Sqlist &L,int s,int t){
    int i,j;
    if(s>=t||L.length==0) return false;
    for(i=0,i<L.length&&L.data[i]<s;i++) //寻找值>=s的第一个元素 
      if(i>=L.length) return false;
    for(j=i;j<L.length&&L.data[j]<=t;j++) //寻找值>t的第一个元素
    for(;j<L.length;i++,j++)
      L.data[i]=L.data[j];
    L.length=i+1;
    return true; 
    
} 

从顺序表中删除其值为定值s与t之间（包含st，要求是s<t）的所有元素即值为st的也要删除，如果s t不合理或顺序表为空则显示错误信息并返回
/**算法思想：从前向后扫描顺序表，用k记录元素值在s-t之间的元素的个数（初始k=0）
 对于当前扫描的元素，若其值不在st之间，则前移k个位置，否则执行k++**/
 bool del_s_t1(Sqlist &L,int s,int t){
     int k,i=0;
     if(L.length==0||s>=t) return false;
     for(i=0;i<L.length;i++){
        if(L.data[i]>=s&&L.data[i]<=t)
         k++;
         else 
         L.data[i-k]=L.data[i];
   }
   L.length-=k;
   return true;
 } 

 

 

从有序数组中删除所有其值重复的元素，使表中所有元素的值均不同
bool delete_same(Sqlist &L){
    if(L.length==0) return false;
    int i,j;  //i存储第一个不相同的元素，j为工作指针 
    for(i=0,j=1;j<L.length;j++)
      if(L.data[i]!=L.data[j])  //查找下一个与上个元素值不同的元素
        L.data[++i]=L.data[j];  //前移
    L.length=i+1;
    return true; 
} 

 

将两个有序顺序表合并成一个新的有序顺序表，并由函数返回结果顺序表
bool Merge(Sqlist A,Sqlist B,Sqlist &c){
    if(A.length+B.length>C.maxsize) return false;
    int i=o,j=o,k=0;
    while(i<A.length&&j<B.length){
        if(A.data[i]<=B.data[j])
           C.data[k++]=A.data[i++];
        else
          C.data[k++]=B.data[j++];
    }
    while(i<A.length)
     C.data[k++]=A.data[i++];
    while(j<B.length)
     C.data[k++]=B.data[j++];
    C.length=K+1;
    return true;
} 

 

线性表（a1 a2..an）中的元素递增有序且按顺序存储在计算机内。要求设计一算法完成用最少的时间
在表中查找数值为x的元素。若找到将其与后继元素位置相交换，若找不到将其插入表中并使表中元素仍递增有序
/**二分法**/
int BinarySearch(int x){
    int low=0;high=n-1,mid;
    while(low<=high){
        mid=(low+high)/2;
        if(A[mid]==x) return mid;
        else if(A[mid]<x) low=mid+1;
        else high=mid-1;
    } 
    return -1;
} 
void SearchExchangeInsert(int A[],int x){
    int mid,temp;
    mid=BinarySearch(x);
    if(mid!=-1&&mid!=n-1){
        temp=A[mid];A[mid]=A[mid+1];A[mid+1]=temp;
    }
    if(mid==-1)
    for(i=n-1;A[i]>x;i--) A[i+1]=A[i];//后移
    A[i+1]=x; 
}

 

位置互换
void Reverse(int A[],int left,int right,int arraySize){
    if(left>=right||right>=arraySize) return;
    int mid=(left+right)/2;
    for(int i=0;i<=mid-left,i++){
        int temp=A[left+i];
        A[left+i]=A[right-i];
        A[right-i]=temp;
    }
} 

 

给定一个含n个整数的数组，设计时间上高效算法找出数组中未出现的最小正整数
int findMissMin(int A[],int n){
    int i,*B;
    B=(int *)malloc(sizeof(int)*n);
    memset(B,0,sizeof(int)*n);  //赋初值为0
    for(i=0;i<n;i++)
       if(A[i]>0&&A[i]<n) B[A[i]-1]=1;
    for(i=o;i<n;i++)
      if(B[i]==0) break;
      return i+1
}