【数据结构】线性表（一）：顺序列表

　　线性表(linear_list)是最常用且最简单的一种数据结构，简言之，一个线性表是n个数据元素的有序序列。

 

例如：（a₁ , ... , a_i-1 , a_i , a_i+1 , ... , a_n)：a_i-1 是 a_i 的直接前驱，a_i+1 是 a_i 的直接后驱。

并且，当 i = 1，2，... ，n-1：a_i 有且只有一个直接后驱。当 i = 2，3，... ，n：a_i 有且只有一个直接前驱

　　

例子：已知线性表LA，LB中的数据元素按值非递减有序排列，现将LA，LB按值非递减排列合并为LC。其伪代码为：

void MergeList(List La, List Lb, List &Lc) {
        initList(Lc);  //初始化Lc
        i = j = 1;
        k = 0;
        La_len = ListLength(La);
        Lb_len = ListLength(Lb);
        while((i <= La_len) && (j <= Lb_len){//La与Lb均非空
            GetElem(La, i, ai);
            GetElem(Lb, j, bj);
            if(ai <= bj) {ListInsert(Lc, ++k, ai); ++i; }
            else{ListInsert(Lc, ++k, bi); ++j;}
        }
        while(i <= La_len){       //La中剩余值插入Lc
            GetElem(La, i++, ai);
            ListInsert(Lc, ++k, ai);
        }
        while(j <= Lb_len){       //Lb中剩余值插入Lc
            GetElem(Lb, j++, bj);
            ListInsert(Lc, ++k, bj);
        }
}

　　分析：GetElem 和 ListInsert 这两个操作的执行时间和表长无关，所以该算法的事件复杂度为O(ListLength(LA) + ListLength(LB))。

 

线性表的顺序表示和实现：顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。

所以可以用 LOC(a_i) = LOC(a₁) + (i-1) * l  来表示a_i的地址（其中：l 表示每个元素所占存储单元）

优点：轻松实现随机存储。

顺序表的初始化、插入、删除、合并的伪代码如下：

 

// -------------线性表的动态分配顺序存储结构--------------
#define LIST_INIT_SIZE 100   //线性表存储空间的初始化分配量
#define LISTINCREMENT 10     //线性表存储空间的分配增量
typedef struct{
    ElemType *elem;     //存储空间基址
    int length;         //当前长度
    int listsize;       //当前分配的存储容量(以sizeof(ElemType)为单位)
}SqList;

//-----------初始化顺序表--------------
Status InitList_Sq(SqList &L){
    //构造一个空的线性表
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if(! L.elem)  eixt(OVERFLOW);       //存储分配失败
    L.length = 0;                       //空表长度为0
    L.listsize = LIST_INIT_SIZE;        //初始存储容量
    return OK;
}

//------------顺序表的插入算法-------------时间复杂度为O(n)
Status ListInsert_Sq(SqList &L, int i, ElemType e) {
    //在顺序线性表L中第i个位置之前插入新的元素e
    //i的合法值为1<=i<=ListLength_Sq(L)+1
    if((i<1) || (i>L.length+1))  return ERROR;        //i值不合法
    if(L.length >= L.listsize){           //当前存储空间已满，增加分配
        newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemTpye));
        if(!newbase) exit(OVERFLOW);        //存储分配失败
        L.elem = newbase;               //新基址
        L.listsize += LISTINCREMENT;        //增加存储容量
    }
    q = &(L.elem[i-1]);         //q为插入位置
    for(p = &(L.elem[L.length-1]); p >= q; --p) 
        *(p+1) = *p;            //插入位置及之后的元素右移
        *q = e;             //插入e
        ++L.length;         //表长增一
        return OK;
}

//-------------顺序表的删除操作--------------时间复杂度为O(n)
Status ListDelete_Sq(SqList &L, int i, ElemType &e){
    //在顺序线性表L中删除第i个元素，并用e返回其值。
    if((i<1) || (i>L.length)) return ERROR;     //i值不合法
    p = &(L.elem[i-1]);             //p为被删除元素的位置
    e = *p;         //被删除元素的值赋给e
    q = L.elem + L.length-1;        //表尾元素的位置
    for(++p; p <= q; ++p){
        *(p-1) = *p;    //被删除元素之后的元素左移
    }
    --L.length;         //表长减1
    return OK;
}

//-----------查找制定元素的位序---------------事件复杂度为O(n)
int LocateElem_Sq(SqList L, ElemType e, Status (* compare)(ElemType, ElemType)){
    //在顺序线性表L中查找第1个值与e满足compare()的元素的位序
    //若找到，则返回其在L中的位序，否则返回0
    i = 1;              //i的初值为第一个元素的位序
    p = L.elem;         //p的初值为第一个元素的存储位置
    while(i <= L.length && !(* compare)(*p++, e)) ++i;
    if(i<L.length) return i;
    else return 0;
}

//------------对于顺序表的合并------------------时间复杂度为O(La.length + Lb.length)
void MergeList_Sq(SqList La, SqList Lb, SqList &Lc) {
    pa = La.elem;
    pb = Lb.elem;
    Lc.listsize = Lc.length = La.length + Lb.length;
    pc = Lc.elem = (ElemType *) malloc (Lc.listsize*sizeof(ElemType));
    if(!Lc.elem) exit(OVERFLOW);        //存储分配失败
    pa_last = La.elem + La.length -1;
    pb_last = Lb.elem + Lb.length -1;
    while(pa <= pa_last && pb <= pb_last){  //归并
        if(*pa <= *pb) *pc++ = *pa++;
        else *pc++ = *pb++;
    }
    while(pa <= pa_last) *pc++ = *pa++;
    while(pb <= pb_last) *pc++ = *pa++;
} 

---

 

　　C语言代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LIST_INIT_SIZE 100      //线性表存储空间初始分配量
#define LISTINCREMENT 10        //线性表存储空间的分配增量

typedef struct {
    int *elem;      //存储空间基址
    int length;     //当前长度
    int listsize;   //当前分配的存储空间容量（以sizeof(int)为单位
}SqList;

//初始化一个新表
void InitList_Sq(SqList *L){
    //构造一个空的线性表L
    (*L).elem = (int *) malloc(LIST_INIT_SIZE*sizeof(int));
    if(!(*L).elem) exit(-1);     //存储分配失败
    (*L).length = 0;
    (*L).listsize = LIST_INIT_SIZE;
}

//向表中第i个位置出插入一个数e
void ListInsert_Sq(SqList *L, int i, int e){
    if(i<1 || i>(*L).length+1) {
        printf("插入时i值不合法...\n");
        exit(-1);
    }
    if((*L).length > (*L).listsize) {     //当前存储空间已满，增加分配
        int *newbase = (int *)realloc((*L).elem, ((*L).length+LISTINCREMENT)*sizeof(int));
        if(!newbase) exit(-1);
        (*L).elem = newbase;
        (*L).listsize += LISTINCREMENT;
    }
    int *q = &(*L).elem[i-1];
    for(int *p=&(*L).elem[(*L).length -1];p>=q;--p){
        *(p+1) = *p;
    }
    *q = e;
    ++(*L).length;
}

//删除表中第i个位置的数并返回到e中
void ListDelete_Sq(SqList *L, int i, int *e){
    if(i<1 || i>(*L).length){
        printf("删除时i值不合法...\n");
        exit(-1);
    }
    int *p = &(*L).elem[i-1];       //要删除的元素
    *e = *p;                        //被删除的元素赋值给e
    int *q = &(*L).elem[(*L).length-1];     //表尾元素
    for(++p;p<=q;p++){          //被删除元素之后的元素左移
        *(p-1) = *p;            
    }
    --(*L).length;
}

void MergeList_Sq(SqList La, SqList Lb, SqList *Lc){
    //已知顺序表La，Lb的元素按值非递减排列
    //归并La，Lb得到新的顺序列表Lc，Lc的元素也按值非递减排列
    int *pa = La.elem;
    int *pb = Lb.elem;
    (*Lc).listsize = (*Lc).length = La.length + Lb.length;
    int *pc = (*Lc).elem = (int *)malloc((*Lc).listsize * sizeof(int));
    if(!(*Lc).elem){
        printf("内存分配失败...\n");
        exit(-1);
    }
    int *pa_last = La.elem + La.length -1;      //La的表尾元素地址
    int *pb_last = Lb.elem + Lb.length -1;      //Lb的表尾元素地址
    while(pa<=pa_last && pb<=pb_last){
        if(*pa <= *pb){
            *pc++ = *pa++;
        }else{
            *pc++ = *pb++;
        }
    }
    while(pa<=pa_last){         //插入La剩余的元素
        *pc++ = *pa++;          //插入Lb剩余的元素
    }
    while(pb <= pb_last){
        *pc++ = *pb++;
    }
}

//查看顺序表中第一个的满足compare()的元素的位序
int LocateElem_Sq(SqList L, int e, int (* compare)(int x, int y)){
    int i = 1;
    int *p = L.elem;
    while(i <= L.length && !(*compare)(*p++, e)){
        ++i;
    }
    if(i <= L.length){
        return i;
    }else{
        return 0;
    }
}

int cmp(int x, int y){
    if(x == y){
        //printf("x=y\n");
        return 1;
    }else{
        //printf("x!=y\n");
        return 0;
    }
}
int main(){
    SqList La;
    SqList Lb;
    SqList Lc;
    int N,e;
    InitList_Sq(&La);
    printf("输入La元素的个数N：");
    scanf("%d",&N);
    printf("输入La的元素：");
    while(N--){
        scanf("%d",&e);
        int i =La.length+1;
        ListInsert_Sq(&La,i,e);
    }
    InitList_Sq(&Lb);
    printf("输入Lb元素的个数N：");
    scanf("%d",&N);
    printf("输入Lb的元素：");
    while(N--){
        scanf("%d",&e);
        int i =Lb.length+1;
        ListInsert_Sq(&Lb,i,e);
    }
    printf("此时La中的元素顺序表的值为：");
    for(int i=0;i<La.length;i++){
        printf("%d ",La.elem[i]);
    }
    printf("\nLa.length = %d\tLa.listsize = %d\n",La.length,La.listsize);
    printf("此时Lb中的元素顺序表的值为：");
    for(int i=0;i<Lb.length;i++){
        printf("%d ",Lb.elem[i]);
    }
    printf("\nLb.length = %d\tLb.listsize = %d\n",Lb.length,Lb.listsize);
    ListDelete_Sq(&La,4,&e);
    printf("删除第四个元素后La的元素顺序表的值为：");
    for(int i=0;i<La.length;i++){
        printf("%d ",La.elem[i]);
    }
    printf("\nLa.length = %d\tLa.listsize = %d\te = %d\n",La.length,La.listsize,e);
    MergeList_Sq(La, Lb, &Lc);
    printf("La和Lb合并后得到Lc，其Lc的信息为：\n");
    printf("Lc的元素顺序表为：");
    for(int i=0;i<Lc.length;i++){
        printf("%d ",Lc.elem[i]);
    }
    printf("\nLc.length = %d\tLc.listsize = %d\n",Lc.length,Lc.listsize);
    printf("输入你要在Lc中查找的元素e：");
    scanf("%d",&e);
    printf("该元素e在Lc的位序位：%d\n",LocateElem_Sq(Lc, e, cmp));
158　　　free(La.elem);free(Lb.elem);free(Lc.elem);return 0;
}

---

　　结果为：