数据结构【线性表】

首先附上最完整的代码实现：尊重原创（图文并茂）

线性表的定义（图文并茂）：

1.线性表的定义

若将线性表记为（a1,...,ai-1,ai,ai+1,...,an），则表中ai-1领先于ai，ai领先于ai+1，称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。
线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。

---

2.线性表的顺序存储结构

线性表的顺序存储结构（数组模拟），指的是一段地址连续的存储单元依次存储线性表的数据元素。

2.1地址计算方法

用数组存储顺序表意味着要分配固定长度的数组空间，分配的数组空间大于等于当前线性表的长度，数据元素的序号和存放它的数组下标之间存在对应关系：

存储器的每个存储单元都有自己的编号，这个编号称为地址。

每个数据元素都需要占用一定的存储单元空间的，假设占用的是c个存储单元，对于第i个数据元素ai存储位置为（LOC表示获得存储位置的函数）：

LOC(ai) = LOC(a1) + (i-1)*c。

---

2.2线性表顺序存储的结构代码：

首先我们写一个顺序存储：（数组模拟）

内置函数：

Status ListClear(Sqlist &L)——清空

Status GetElem(const Sqlist &L,const int &i,ElemType &e)——询问

Status ListInsert(Sqlist &L,int i,ElemType e)——插入

Status ListDelete(Sqlist &L,int i,ElemType &e)——删除

---

第一步：我们需要定义出来结构体：

typedef struct Sqlist{
    ElemType data[MAXSIZE];
    int length;
    Sqlist(){
        length=0;
    }
}Sqlist;

 第二步：我们需要把上述的函数 一 一实现：

清空：

/* 重置为空表——清空*/
Status ListClear(Sqlist &L){
    memset(L.data,0,sizeof(L.data));
    L.length=0;
    return OK;
}

 查询：

/* 获取某个下标的元素的值——查询*/
Status GetElem(const Sqlist &L,const int &i,ElemType &e){
    if(L.length==0||i<1||i>L.length){
        printf("询问时:下标 %d,不合法。\n",i);
        return ERROR;
    }
    e=L.data[i-1];
    return OK;
}

 插入：

/* 指定某个位置插入某元素——插入*/
Status ListInsert(Sqlist &L,int i,ElemType e){
    int k,len=L.length,temp;
    if(len>=MAXSIZE){
        printf("错误提醒：线性表已满\n\n");
        return ERROR;
    }else if(i<1||i>len+1){
        printf("错误提醒：所插入的位置%d ,位置不合法\n\n",i);
        return ERROR;
    }else if(i<=len){
        for(k=len-1;k>=i-1;k--){
            L.data[k+1]=L.data[k];
        }
    }
    L.data[i-1]=e;
    L.length++;
    printf("下标为：%d , 元素为：%d ,插入元素成功\n\n",i,e);
    /*检查每个位置元素*/
    for(int i=1;i<=L.length;i++){
        GetElem(L,i,temp);
        printf("第%d个 :%d\n",i,temp);
    }
    printf("\n");
    return TRUE;
}

 删除:

/*删除指定下标的某个元素*/
Status ListDelete(Sqlist &L,int i,ElemType &e){
    int k;
    if(L.length==0){
        printf("线性表为空\n");
        return ERROR;
    }
    if(i<1||i>L.length){
        printf("错误提示：删除的下标：%d\n",i);
        return ERROR;
    }
    e=L.data[i-1];
    if(i<L.length){
        for(k=i;k<=L.length;k++){
            L.data[k-1]=L.data[k];
        }
    }
    printf("删除成功，删除元素下标为：%d . 删除元素为：%d\n",i,e);
    L.length--;
    return OK;
}

---

第三步：测试每个函数实现功能

附上自己测试的代码：

#include<stdio.h>         //线性表：顺序存储结构
#include<string.h>
#define MAXSIZE 9
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int ElemType;
typedef int Status;
typedef struct Sqlist{
    ElemType data[MAXSIZE];
    int length;
    Sqlist(){
        length=0;
    }
}Sqlist;
Status ListShow(Sqlist &L);
/* 重置为空表——清空*/
Status ListClear(Sqlist &L){
    memset(L.data,0,sizeof(L.data));
    L.length=0;
    return OK;
}
/* 获取某个下标的元素的值——查询*/
Status GetElem(const Sqlist &L,const int &i,ElemType &e){
    if(L.length==0||i<1||i>L.length){
        printf("询问时:下标 %d,不合法。\n",i);
        return ERROR;
    }
    e=L.data[i-1];
    return OK;
}
/* 指定某个位置插入某元素——插入*/
Status ListInsert(Sqlist &L,int i,ElemType e){
    int k,len=L.length,temp;
    if(len>=MAXSIZE){
        printf("错误提醒：线性表已满\n\n");
        return ERROR;
    }else if(i<1||i>len+1){
        printf("错误提醒：所插入的位置%d ,位置不合法\n\n",i);
        return ERROR;
    }else if(i<=len){
        for(k=len-1;k>=i-1;k--){
            L.data[k+1]=L.data[k];
        }
    }
    L.data[i-1]=e;
    L.length++;
    printf("下标为：%d , 元素为：%d ,插入元素成功\n\n",i,e);
    /*检查每个位置元素*/
    ListShow(L);
    printf("\n");
    return TRUE;
}
/*删除指定下标的某个元素*/
Status ListDelete(Sqlist &L,int i,ElemType &e){
    int k;
    if(L.length==0){
        printf("线性表为空\n");
        return ERROR;
    }
    if(i<1||i>L.length){
        printf("错误提示：删除的下标：%d\n",i);
        return ERROR;
    }
    e=L.data[i-1];
    if(i<L.length){
        for(k=i;k<=L.length;k++){
            L.data[k-1]=L.data[k];
        }
    }
    printf("删除成功，删除元素下标为：%d . 删除元素为：%d\n",i,e);
    L.length--;
    return OK;
}
Status ListShow(Sqlist &L){
    int temp;
    if(L.length==0){
        printf("访问的线性表为空\n");
        return ERROR;
    }
    for(int i=1;i<=L.length;i++){
        GetElem(L,i,temp);
        printf("%d%c",temp,i==L.length?'\n':' ');
    }
    return OK;
}
int main()
{
    Sqlist L;
    int a[]={1,2,3,4,5,6,7},ans,temp;

    memcpy(L.data,a,sizeof(a));
    L.length=7;
    ListShow(L);
    /*测试——询问环节*/
    printf("\n****测试——询问环节****\n\n");
    if(GetElem(L,2,ans)){
        printf("%d\n",ans);
    }
    if(GetElem(L,8,ans)){
        printf("%d\n",ans);
    }
    /*测试——插入环节*/
    printf("\n****测试——插入环节****\n\n");
    ListInsert(L,2,10);
    ListInsert(L,-1,222);
    ListInsert(L,10,222);
    ListInsert(L,7,222);
    ListInsert(L,7,32);

    /*测试——清空环节*/
    printf("\n****测试——清空环节****\n\n");
    ListClear(L);
    printf("%d\n",L.length);

    Sqlist La,Lb;

    memcpy(La.data,a,sizeof(a));
    La.length=7;

    ListShow(La);

    /*测试——删除环节*/

    printf("\n****测试——删除环节****\n\n");

    ListDelete(La,3,temp);


    ListDelete(La,10,temp);
    ListDelete(La,-1,temp);

    return 0;
}

链式线性表：

#include<time.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define OK      1
#define ERROR   0
#define TRUE    1
#define FALSE   0
typedef int Status;
typedef int ElemType ;
typedef struct Node {
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node * LinkList;
/*
询问环节，通过历遍整个链表来找到对应下标的元素。
注意抛出不合法情况。
*/
Status GetElem(LinkList head,int i,ElemType &e)
{
    int j=1;
    LinkList p;
    p=head->next;
    while(p&&j<i){
        p=p->next;
        j++;
    }
    if(!p||i<j){
        if(!p){
            printf("错误提示：所给下标的值:%d ,比链表长度:%d要长",i,j);
        }else if(i<j){
            printf("错误提示：所给下标的值:%d不合法",i);
        }
        return ERROR;
    }
    e=p->data;
    printf("询问成功！！！\n");
    return OK;
}
/*
插入环节：找到对应的下标，插入元素。
注意要抛出不合法的情况。
*/
Status ListInsert(LinkList *head,int i,ElemType e){
    int j=1;
    LinkList p=*head;

    while(p&&j<i){
        p=p->next;
        j++;
    }

    if(!p||i<j){
        if(!p){
            printf("错误提示：所给下标的值:%d ,比链表长度:%d要长",i,j);
        }else if(i<j){
            printf("错误提示：所给下标的值:%d不合法",i);
        }
        return ERROR;
    }

    LinkList s=(LinkList)(malloc(sizeof(Node)));

    s->data=e;
    s->next=p->next;
    p->next=s;
    printf("插入成功!!!\n");
    return OK;

}
Status ListDelete(LinkList &L,int i,ElemType &e){
    int j=0;
    LinkList p=L;
    while(  (p->next)&&(j<i-1)  ){
        p=p->next;
        j++;
    }
    if(     (!p)    ||  (j>i-1)  ){
        printf("删除失败！！！\n所删除的下标为：%d\n",i);
        return ERROR;

    }
    LinkList q=p->next;
             p->next=q->next;
    e=q->data;
    free(q);
    printf("删除：下标：%d    元素：%d\n",i,e);
    return OK;
}
Status ListShow(LinkList &L){
    LinkList p=L->next;
    if(!p){
        printf("所在的链式线性表为空\n");
        return ERROR;
    }
    while(p->next){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}
Status CreateListHead(LinkList *L,int n){

    LinkList p;
    srand(time(0));
    int i;

    *L=(LinkList)malloc(sizeof(Node));
    (*L)->next=NULL;

    for( i = 0 ; i < n ;i ++ ){
        p=(LinkList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        p->next=(*L)->next;
        (*L)->next=p;
    }
}
Status CreateListTail(LinkList *L,int n){

    LinkList p;
    srand(time(0));
    int i;

    *L=(LinkList)malloc(sizeof(Node));
    (*L)->next=NULL;

    LinkList tail;
    tail = *L;
    for( i = 0 ; i < n ;i ++ ){
        p=(LinkList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
}
Status ListClear(LinkList *L){
    int i;
    LinkList p,q;
    p=(*L)->next;
    while( p ){
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
    return OK;
}
int main()
{
    LinkList a;
    CreateListTail(&a,10);
    ListShow(a);
    ListClear(&a);
    ListShow(a);
    int e;
    LinkList head =(LinkList)malloc(sizeof(Node));
    LinkList s1=(LinkList)malloc(sizeof(Node));
    s1->data=4;
    s1->next=NULL;
    head->next=s1;
    ListInsert(&head,1,2);
    ListInsert(&head,2,3);
    ListInsert(&head,2,7);
    ListInsert(&head,3,5);
    GetElem(head,3,e);
    printf("询问：下标：%d    元素：%d\n",3,e);
    ListDelete(head,2,e);
    return 0;

}