线性表->顺序存储

文字描述：

　　用一组地址连续的存储单元依次存储线性表的数据元素，只要确定了存储线性表的起始位置，线性表中任一数据元素都可随机存取，所以线性表的顺序存储结构是一种随机存取的存储结构。

　　即是，线性表的顺序存储结构的特定是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中任一元素，它的存储位置可用一个简单、直观的公式来表示。但是这也导致了它的一个弱点，在作插入或删除操作时，需移动大量元素。

示意图

 

算法分析

　　在顺序存储结构的线性表中某个位置上插入或删除一个数据元素，其时间主要耗费在移动元素上，而移动的元素个数取决于插入或删除的位置。故其插入和删除的时间复杂度为n。

　　在顺序存储结构的线性表中求“表长”和“取第i个数据元素”的时间复杂度为1。

　　在顺序存储结构的线性表中，union算法(将所有在线性表Lb但不在线性表La中的数据元素插入到La，即La=La U Lb), 其时间复杂度为La.length X Lb.length; 但是如果La，Lb是有序的，另外新建Lc存放结果，其时间复杂度将变为MAX(La.length+Lb.length).

代码实现

//
// Created by lady on 19-1-26.
//

/*
现性表的顺序表示和实现
现性表的顺序表示:用一组地址连续的存储单元依次存储线性表的数据元素。
*/
#include <stdio.h>
#include <stdlib.h>

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

/*构造一个空的线性表*/
static int InitList_Sq(SqList *L)
{
    if(L==NULL){
        return -1;
    }
    if((L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType))) == NULL){
        //存储分配失败
        return -1;
    }
    //空表长度为0
    L->length = 0;
    //初始存储容量
    L->listsize = LIST_INIT_SIZE;
    return 0;
}

/*在L中第i个位置之前插入新的数据元素e，L的长度增1*/
static int ListInsert_Sq(SqList *L, int i, ElemType e)
{
    //i的合法值为1 <= i <= ListLength_Sq(L)+1
    if((i<1) || (i>L->length+1))
        return -1;
    if(L->length >= L->listsize){
        //当前存储空间已满，增加分配
        ElemType *newbase = NULL;
        if((newbase=(ElemType*)realloc(L->elem, (L->listsize+LIST_INCREMENT)*sizeof(ElemType))) == NULL){
            //存储分配失败
            return -1;
        }
        //新的基址
        L->elem = newbase;
        //增加存储容量
        L->listsize += LIST_INCREMENT;
    }
    //q为插入位置
    ElemType *q = (L->elem+i-1);
    ElemType *p;
    for(p=(L->elem+L->length-1); p>=q; --p){
        //插入位置及之后的元素右移
        *(p+1) = *p;
    }
    //插入e
    *q = e;
    //表长增1
    L->length += 1;
    return 0;
}

/*删除L中的第i个数据元素，并用e返回其值， L的长度减1*/
static int ListDelete_Sq(SqList *L, int i, ElemType *e)
{
    //i的合法值为1 <= i <= ListLength_Sq(L)
    if((i<1) || (i>L->length)){
        return -1;
    }
    ElemType *p;
    ElemType *q;
    //p为被删除元素的位置
    p = L->elem+i-1;
    //被删除元素的值赋给e
    *e = *p;
    //表尾元素的位置
    q = L->elem+L->length-1;
    for(++p;p<=q;++p){
        //被删除元素之后的元素坐移
        *(p-1) = *p;
    }
    //表长减1
    L->length -= 1;
    return 0;
}

/*依次对L的每个数据元素调用函数fun。一旦fun失败，则操作失败*/
static int ListTraverse_Sq(SqList L, int (*fun)(ElemType,int), char info[])
{
    printf("顺序存储的线性表%s", info);
    int i = 0;
    for(i=0; i<L.length; i++)
    {
        if(fun(L.elem[i],i+1) < 0){
            printf("Err:when traverse(e,%d) wrong!
",i);
            return -1;
        }
    }
    printf("
");
    return 0;
}

/*
 * 在顺序表L中查找第1个值与e满足fun的元素的位序
 * 若找到， 则返回其在L中的位置， 否则返回0
 */
static int LocateElem_Sq(SqList L, ElemType e, int (*fun)(ElemType,ElemType))
{
    //i的初值为第一个元素的位置
    int i = 1;
    ElemType *p;
    //p的初值为第一个元素的存储位置
    p = L.elem;
    while(i<=L.length && (fun(*p++,e)))
        ++i;
    if(i<=L.length)
        return i;
    return 0;
}

/*销毁线性表L*/
static int DestroyList_Sq(SqList *L)
{
    if(L == NULL)
        return -1;
    if(L->elem){
        free(L->elem);
        L->elem = NULL;
    }
    L->length = 0;
    L->listsize = 0;
    return 0;
}

/*
 * 已知顺序线性表La和Lb的元素按照非递减排列
 * 归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列
 * 时间复杂度为MAX(La.length, Lb.length)
 */
static int MergeList_Sq(SqList La, SqList Lb, SqList *Lc)
{
    if(Lc == NULL){
        return -1;
    }

    ElemType *pa = La.elem, *pa_last;
    ElemType *pb = Lb.elem, *pb_last;

    Lc->length = La.length + Lb.length;
    Lc->listsize = La.length + Lb.length;

    if((Lc->elem = (ElemType*)malloc(Lc->listsize * sizeof(ElemType))) == NULL){
        //存储分配失败
        Lc->length = 0;
        Lc->listsize = 0;
        return -1;
    }
    ElemType *pc = Lc->elem;

    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){
        //插入La的剩余部分
        *pc++ = *pa++;
    }
    while(pb<=pb_last){
        //插入Lb的剩余部分
        *pc++ = *pb++;
    }
    return 0;
}

//打印位置loc和其数据元素e
static int printE(ElemType e, int loc)
{
    printf("%3d=%-3d", loc, e);
    return 0;
}

//比较元素e1和e2是否相等， 相等返回0,否则返回-1
static int equal(ElemType e1, ElemType e2)
{
    if(e1==e2){
        return 0;
    }else{
        return -1;
    }
}

int main(int argc, char *argv[])
{
    SqList L;
    if(InitList_Sq((&L)) < 0){
        printf("Err:init sqList wrong!
");
        goto End;
    }

    ElemType e;
    int location;
    int data;

    //以插入法构造一个线性表·[12,13,21,24,28,30,42,77]
    ListInsert_Sq(&L, 1, 12);
    ListInsert_Sq(&L, 2, 13);
    ListInsert_Sq(&L, 3, 21);
    ListInsert_Sq(&L, 4, 24);
    ListInsert_Sq(&L, 5, 28);
    ListInsert_Sq(&L, 6, 30);
    ListInsert_Sq(&L, 7, 42);
    ListInsert_Sq(&L, 8, 77);
    ListTraverse_Sq(L, printE, "L:");
    printf("
");

    //insert a data and print
    printf("insert a data and print, please input (locatioon, data):");
    scanf("%d,%d", &location, &data);
    ListInsert_Sq(&L, location, data);
    ListTraverse_Sq(L, printE, "L:");
    printf("
");

    //delete a data and print
    printf("delete a data and print, please input (location):");
    scanf("%d", &location);
    ListDelete_Sq(&L, location, &e);
    ListTraverse_Sq(L, printE, "L:");
    printf("
");

    //locate a data and print
    printf("locata a data and print, please input (data):");
    scanf("%d", &data);
    location = LocateElem_Sq(L, data, equal);
    printf("the location of the first data who equals to %d is %d!

", data, location);

    printf("Merge LA and LB to  LC!
");
    SqList La, Lb, Lc;
    if(InitList_Sq(&La) || InitList_Sq(&Lb)){
        printf("Err:init sqList wrong!
");
        goto End;
    }
    //构造一个值非递减的线性表：LA [3,5,8,11]
    ListInsert_Sq(&La, 1, 3);
    ListInsert_Sq(&La, 2, 5);
    ListInsert_Sq(&La, 3, 8);
    ListInsert_Sq(&La, 4, 11);
    ListTraverse_Sq(La, printE, "LA");

    //构造一个值非递减的线性表：LB [2,6,8,9,11,15,20]
    ListInsert_Sq(&Lb, 1, 2);
    ListInsert_Sq(&Lb, 2, 6);
    ListInsert_Sq(&Lb, 3, 8);
    ListInsert_Sq(&Lb, 4, 9);
    ListInsert_Sq(&Lb, 5, 11);
    ListInsert_Sq(&Lb, 6, 15);
    ListInsert_Sq(&Lb, 7, 20);
    ListTraverse_Sq(Lb, printE, "LB");

    //将线性表La和Lb按照非递减形式归并成线性表Lc
    if(MergeList_Sq(La, Lb, &Lc))
    {
        printf("Err:when merge(La,Lb) wrong!
");
        goto End;
    }
    ListTraverse_Sq(Lc, printE, "LC");

End:
    DestroyList_Sq(&L);
    DestroyList_Sq(&La);
    DestroyList_Sq(&Lb);
    DestroyList_Sq(&Lc);
    return 0;
}

代码运行

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
顺序存储的线性表L:  1=12   2=13   3=21   4=24   5=28   6=30   7=42   8=77 

insert a data and print, please input (locatioon, data):5,25
顺序存储的线性表L:  1=12   2=13   3=21   4=24   5=25   6=28   7=30   8=42   9=77 

delete a data and print, please input (location):5
顺序存储的线性表L:  1=12   2=13   3=21   4=24   5=28   6=30   7=42   8=77 

locata a data and print, please input (data):42
the location of the first data who equals to 42 is 7!

Merge LA and LB to  LC!
顺序存储的线性表LA  1=3    2=5    3=8    4=11 
顺序存储的线性表LB  1=2    2=6    3=8    4=9    5=11   6=15   7=20 
顺序存储的线性表LC  1=2    2=3    3=5    4=6    5=8    6=8    7=9    8=11   9=11  10=15  11=20 

Process finished with exit code 0