王道数据结构(顺序表)

顺序表定义

#define MAX 100
typedef int Position;

typdef struct{
    ElemType data[MAX];
    Position last;
}List;

1.删除顺序表中最小的元素(值唯一),空出的元素由最后一个补

bool del_Min(List &L,ElemType e){
    if(L.length==0) return false;
    e=L.data[0];
    int temp=0;
    for(int i=1;i<L.length;i++){
        if(L.data[i]<e){
             e=L.data[i];
             temp=i;
            }
       }
    L.data[temp]=L.data[L.length-1];
    L.length--;
    return true;
}

2.将顺序表中所有元素逆置，要求空间复杂度O(1）

void reverse(List 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;
        }
}

3.长度为n的顺序表L删除其中所有值为X的元素，要求时间复杂度O(N)空间复杂度O(1)

void del_X(List &L,ElemType X){
    int k=0;
    for(int i=0;i<L.length;i++){
        if(L.data[i]!=X)
            L.data[K++]=L.data[i];
          }
    L.length=k;
}

4.从有序线性表里删除值在s,t（s<t)间的所有元素

bool del_betweenSAndT(List &L,Elemtype s,ElenType t){
    int i,j;
    if(s>=t||L.length==0)
        return false; 
    for(i=0;i<L.length&&L.data[i]<s;i++)  ;
    if(i>=L.length)    
        returnn false;
    for(j=1;j<L.length&&L.data[i]<=t;j++) ;
    for(;j<L.length;i++,j++)
        L.data[i]=L.data[j];
    L.length=i;
    return true;
}

5.从线性表中删除值在s,t（s<t)间的所有元素

bool del_s_t(List &L,ElemType s,ElemType t){
    int i,k=0;
    if(L.length==0||s>=t)
        return false;
    for(int 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;
  }

6.从有序线性表中删除值重复的元素

bool delSame(List &L){
    if(L.length==0)
        return false;
    for(int 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;
}

7.合并两个有序线性表

void merge(List A,List B,List C){
    int i=0,j=0,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.daya[j++];
        }
    while(i<A.length)
           C.data[k++]=A.data[i++];
    while(j<B.length)
           C.data[k++]=B.data[j++];
    C.length=K;
}

8.已知在一维数组A[m+n]中依次存放两个线性表，写一个函数实现两个线性表位置互换

typedef int DataType;
void reverse(DataType A[],int left,int right,int arraysize){//arraysize为数组大小？
        if(left>=right||right>=arraysize)
                return ;
        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]=temp;
          }
}
void exchge(DataType A[],int m,int n,int arraysize){
    reverse(A,0,m+n-1,arraysize);//逆置整个数组
    reverse(A,0,n-1,arraysize);  //逆置后半部分
    reverse(A,n,m-n-1,arraysize);//逆置前半部分
}    

9.线性表中元素有序递增，且按顺序存储在计算机中，要求设计一算法在最短时间内查找到值为X的元素，若找到将其与后继元素互换，若不存在将其插入到表中，并保持有序递增性

vooid serach(ElemType A[],ElemType X){
    int start=0,end=A.length-1，mid;
    while(start<=end){
            mid=(start+end)/2;
            if(A[mid]==X) break;
            else  if(A[mid]<X)   start=mid+1;
                  else           end=mid-1;
          }
    if(A[mid]==x&&mid!=A.length-1){
        int t=A[mid];
        A[mid]=A[mid+1];
        A[mid+1]=t;
    }
    if(start>end){
        for(i=A.length-1;i>end;i--)
            A[i+1]=A[i];
        A[i+1]=X;
    }
}

10.数组A[n]循环右移p(0<p<n)