线性表的顺序表示

0、顺序表的底层是由一维数组实现的，而关于一维数组有两种空间分配方式，分别是静态分配和动态分配：

/*
   静态分配
   #define MaxSize 20
   typedef int ElemType
*/
typedef struct Node {
    ElemType data[MaxSize];
    int Last;
} SqList;
/*
   动态分配
   #define InitSize  100
   #define MaxSize 20
   typedef int ElemType
*/
typedef struct Node {
    ElemType *data;
    int Length;
    int MaxSize;
} SqList;

/*对于动态分配，其C语言的初始动态分配的语句是：*/

L.data=(ElemType *)malloc(sizeof(ElemType)*InitSize);

/*对于动态分配，其C++语言的初始动态分配的语句是：*/

L.data=new ElemType[InitSize];

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

bool DelMin(SqList &L,ElemType &value) {
    if(L.length==0) {
        cout << "顺序表为空";
        return false;
    }
    int min=L.Data[0],pos;
    for(int i=0; i<L.Length; i++) {
        if(L.Data[i]<min) {
            value=L.Data[i];
            pos=i;
        }
    }
    L.Data[pos]=L.Data[length-1];
    L.Length--;
    return true;
}

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

 

void Reverse(SqList &L) {
    ElemType temp;
    for(int 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,编写一个时间复杂度为0(n)、 空间复杂度为0(1)的算法，该算法删除线性表中所有值为x的数据元素。

void del_x(SqList &L,ElemType x) {
    int k=0;
    for(int i=0; i<L.length; i++)
        if(L.data[i]==x)
            k++;
        else
            L.data[i-k]=L.data[i];
    L.length-=k;
}

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

bool del_s_t(SqList &L,ElemType s,ElemType t) {
    if(s>=t || L.length==0) {
        cout << "s或t不合理或顺序表为空";
        return false;
    }
    int i,j;
    for(i=0; i<L.length && L.data[i]<=s; i++)
        if(i>=L.length)
            return false;
    for(j=i; j<L.length && L.data[j]<t; j++)
        for(; j<L.length; i++,j++)
            L.data[i]=L.data[j];
    L.length=i;//注意不是i+1
    return true;
}

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

bool del_s_t(SqList &L,ElemType s,ElemType t) {
    if(s>=t || L.length==0) {
        cout << "s或t不合理或顺序表为空";
        return false;
    }
    int k=0;
    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(SqList &L) {
    if(L.length==0) {
        cout << "顺序表为空";
        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. 将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。

/*由于生成了一个新顺序表，第一个元素需要存在，故采用X.data[i++]格式*/
bool Merge(SqList A,SqList B,SqList &C) {
    if(A.length+B.length>C.MaxSize)
        return false;
    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.data[k++];
    while(i<A.length)
        C.data[k++]=A.data[i++];
    while(j<B.length)
        C.data[k++]=B.data[j++];
    C.length=k;
    return true;
}

8. 已知在一维数组A[m + n]中依次存放两个线性表(a1, a2, a3, ..., am)和(b1, b2, b3, ..., bn). 试编写一个函数，将数组中两个顺序表的位置互换，即将(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;
    int mid=(left+right)/2;
    for(int i=0; i<mid-left; i++) {
        DataType temp=A[left+i];
        A[left+i]=A[left-i];
        A[left-i]=temp;
    }
}
void Exchange(DataType A[],int m,int n) {
    Reverse(A,0,m+n-1,m+n);
    Reverse(A,0,n-1,m+n);
    Reverse(A,n,m+n-1,m+n);
}