数据结构线性表的代码实现--顺序表、单链表、双链表

最近学习完了数据结构的第二章–线性表，王道的教材，在此自我总结。

首先是顺序表：
顺序表的定义–静态分配和动态分配：

静态分配代码实现：

#define MaxSize 50 // define类似java里的常数设定，一旦设定，之后的代码无法修改此数据
typedef struct{
    ElemType data[MaxSize]; //用静态的数组存放数据结构
    int length;
}SqList;

静态分配时数组的大小和空间是事先确定的，因此一旦将空间填满，再加入新数据会导致程序崩溃。

动态分配：

#include <stdlib.h>
#define InitSize 10
typedef struct{
    int *data; //指向顺序表中第一个元素
    int MaxSize;
    int length;
}SqList;

void InitList(SqList &L){
    L.data=(int *) malloc (InitSize*sizeof(int));
    L.length=0; // 初始化顺序表，若少了这一句，则分配的这片空间内遗留的“脏数据”就会留下
    L.MaxSize=InitSize;
}

void IncreaseSize(SqList &L, int len){
    int *p=L.data;
    L.data=(int *) malloc ((L.MaxSize+len) * sizeof(int));
    for(int i=0; i<L.length; i++){
        L.data[i]=p[i]; // 将数据复制到新区域（麻烦，时间开销大）
    L.MaxSize=L.MaxSize+len;
    free(p); // 释放原来的内存空间，malloc和free函数必须成对出现
}

int main(){
    SqList L;
    InitList(L);
    .......// 一些其他操作，比如插入一些元素
    IncreaseSize(L,5);
    return 0;
}

个人理解：动态分配就是增加多少长度就重新开创一片新内存，再把之前顺序表的内容重新存入。使用malloc函数申请的内存是整片且连续的，因此依然是随机存取方式。

顺序表插入操作–在第i个位置插入元素e:

bool ListInsert(SqList &L, int i , ElemType e){
    if(i<1 || i>L.length+1)
        return false;
    if(L.length>=MaxSize)
        return false;
    for(int j=L.length; j>=i; j--)
        L.data[j]=L.data[j-1]; // 将第i个元素及之后的元素后移
    L.data[i-1]=e;
    L.length++;
    return true; //插入成功则返回true
}

顺序表删除操作–删除第i个位置的元素，并将此处的值e返回：

bool ListDelete(SqList &L, int i, ElemType &e){
    if(i<1 || i>L.length)
        return false;
    e=L.data[i-1];
    for(int j=i; j<L.length; j++)
        L.data[j-1]=L.data[j];
    L.length--;
    return true;
}

顺序表按值查找–查找值为e的元素，返回其位序：

int LocateElem(SqList L; ElemType e){
    int i;
    for(i=0; i<L.length; i++)
        if(L.data[i]==e)
            return i+1; // 位序和数组下标的区别，勿混淆
    return 0;
}

单链表的初始化（不带头结点）：

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

bool InitList(LinkList &L){
    L=NULL; //防止脏数据遗留
    return true;
}

单链表的初始化（带头结点）：

bool InitList(LinkList &L){
    L=(LNode *) malloc (sizeof(LNode)); // 分配一个头结点
    if (L==NULL)
        return false;
    L->next=NULL;
    return true;
}

注意：在代码中，如果强调这是一个单链表，则使用LinkList，比如传入参数时大多使用 LinkList &L; 如果强调是一个结点，则使用LNode *, 比如头结点的分配。

单链表的创建–头插法：

LinkList List_HeadInsert(LinkList &L){
    LNode *s, int x;
    L=(LinkList) malloc (sizeof(LNode)); //创建头结点
    L->next=NULL; //若缺少此句，头结点可能指向脏数据
    scanf("%d", &x);
    while(x != 6666){
        s= (LNode *) malloc (sizeof(LNode)); //创建新结点
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d",&x);
    }
    return L;
}

注意：头插法建立的单链表与数据是逆序的

尾插法创建单链表：

LinkList List_TailInsert(LinkList &L){
    int x;
    L=(LinkList) malloc (sizeof(LNode));
    LNode *s, *r=L; // r为尾指针
    scanf("%d",&x);
    while(x!=6666){
        s=(LNode *) malloc (sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s; // r指向新的表尾结点
        scanf("%d",&x);
    }
    r->next=NULL;
    return L;
}

尾插法创建单链表是按照数值顺序建立的，头插法与其顺序相反。

按序号查找结点值：

LNode *GetElem(LinkList L, int i){
    int j=1;
    LNode *p=L->next;
    if(i==0)
        return L;
    if(i<1)
        return NULL;
    while(p&&j<i){ //从第一个结点开始查找，直到第i个
        p=p->next;
        j++;
    }
    return p;
}

按值查找结点：

LNode *LocateElem(LinkList L, ElemType e){
    LNode *p=L->next;
    while(p !=NULL && p->data!=e){
        p=p->next;
    return p;
}

带位序插入（带头结点），将值为e的新结点插入第i个位置：

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while (p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *s=(LNode *) malloc (sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

删除第i个结点：

p=GetElem(L,i-1);
q=p->next;
p->next=q->next;
free(q);

求表的长度：

int length(LinkList L){
    int len=0;
    LNode *p=L;
    while(p->!=NULL){
        p=p->next;
        len++;
    }
    return len;
}

双链表：
双链表的初始化（带头结点）：

bool InitDLinkList(DLinkList &L){
    L=(DNode *) malloc (sizeof(DNode));
    if (L==NULL)
        return false;
    L->prior=NULL;
    L->next=NULL;
    return true;
}

typedef struct DNode{
    ElemType data;
    struct DNode *prior, *next;
}DNode, *DLinkList;

双链表的插入：在p后插入s：

bool InsertNextDNode(DNode *p,DNode *s){
    if(p==NULL || s==NULL)
        return false;
    s->next=p->next;
    if (p->next !=NULL)
        p->next->prior=s;
    s->prior=p;
    p->next=s;
    return true;
}

双链表的删除：
删除p结点的后继结点：

bool DeleteNextDNode(DNode *p){
    if (p==NULL){
        return false;
    DNode *q=p->next;
    if(q==NULL)
        return false;
    p->next=q->next;
    if(q->next!=NULL)
        q->next->prior=p;
    free(q);
    return true;
}

循环删除各个数据结点：

void DestroyList(DLinkList &L){
    while (L->next!=NULL)
        DeleteNextDNode(L);
    free(L); //释放头结点
    L=NULL;
}

初始化循环单链表：

bool InitList(LinkList &L){
    L=(LNode *) malloc (sizeof(LNode));
    if (L==NULL)
        return false;
    L->next=L;
    return true;
}