数据结构—顺序表初体验

Posted 2020-10-04

顺序表是是顺序存储的，用一组连续的单位来存放数据，逻辑上相邻的两个数据在物理位置上也是相邻的。

 

顺序表的起始首地址为LOC（A），存放每一个数据所需要的大小为sizeof(Elemtype)，所以顺序表中元素 a_i的存放位置为LOC（A）+ (i-1)sizeof(Elemtype)。

顺序表的定义分为两种，静态分配和动态分配，静态分配是使用一维数组进行数据的存储，表的大小固定，使用过程中容易溢出。而动态分配可以在使用过程中动态的开辟空间。

定义方式如下：

//静态分配
#define MaxSize 50               //最大长度
typedef struct{
    ElemType elem[Maxsize];   //元素
    int length;                         //当前长度
}SeqList;


//动态分配
#define InitSize 50
typedef struct{
    ElemType *elem;
    int MaxSize;
    int length;
}SeqList;

//初始动态分配
L->data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

顺序表的特点是随机访问，可以在O(1)的时间内找到一个指定的元素，但是在插入删除时要移动大量的元素。

 

算法：

1）删去所有值为x的数据元素

void DeleteX(SeqList *L,ElemType x){
    int temp=0;
    for (int i = 0; i < L->length; ++i) {
        if (L->elem[i] != x){
            L->elem[temp]=L->elem[i];
            temp++;
        }
    }
}

2）顺序表中删除值在s和t之间的元素

bool DeleteST(SeqList *L,ElemType s,ElemType t){
    if(s>t||L->length==0)return false;
    int k=0;
    for (int i = 0; i <L->length ; ++i) {
        if(L->elem[i]>=s&&L->elem[i]<=t){
            k++;
        }else{
            L->elem[i-k]=L->elem[i];
        }
    }
    L->length-=k;
    return true;
}

如果顺序表是连续的，按照上面一种方法是可以的，但是如果连续的话，删除的是数组的一整段，所以应该有更优解

bool DeleteST(SeqList *L,ElemType s,ElemType t){
    if(s>t||L->length==0)return false;
    int i,j;
    for (i = 0; i <L->length&&L->elem[i]<s ; ++i);//找到第一个>=s的元素
    if(i>L->length)
        return false;
    for (j = i;j < L->length&&L->elem[j]<=t; ++j);//找到第一个>t的元素
    for (; j<L->length ; ++i,++j) {
        L->elem[i]=L->elem[j];                    //前移
    }
    L->length = i;
    return true;
}

3）循环左移 abcdef->defabc

从移动的地方开始分割，数字可以分成AB两块，换位置首尾位置互换后，得到B^-1A^-1然后对B和A分别首尾互换，就可以得到BA

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

4)求有序A和B中位数

先分别求出A和B的中位数a,b；a>b，舍弃a大的一半和b小的一半，反之亦然；继续比较，a=b时，得到结果或者A和B中均只有一个元素，较小的为中位数；

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]){        //a<b
            if((s1+d1)%2==0){   //奇
                s1=m1;
                d2=m2;
            }
            else{               //偶
                s1=m1+1;
                d2=m2;
            }
        }
        if(A[m1]>B[m2]){        //a>b
            if((s2+d2)%2==0){
                s2=m2;
                d1=m1;
            }
            else{
                s2=m2+1;
                d1=m1;
            }
        }
    }
    return A[s1]<B[s2]?A[s1]:B[s2];
}