数据结构-线性表的链式结构

线性表的链式结构，与之前说过的线性表的顺序结构差不多，区别在于存储结构和方式的不一样。

在链式中，来一个数据就去寻找一个空间存储一个结点有多少数据占多大的地方，是动态的存储方式。另外顺序表如果存储1MB就只占1MB存储空间，但是链式表不一样，它会有额外的空间去存储对应结点的指针。

这样一分析结构就出来了，链式结构为两部分：1.结点域。2.指针域。实现方法用动态存储。

#include "stdio.h"
#include "stdlib.h"

typedef int ElemType;
typedef int Status;
#define ERROR 0
#define OK 1

typedef struct LNode
{
    ElemType data;        //数据域
    struct LNode *next;    //指针域
}LNode, *LinkList;

//构建一个空的线性表L
Status InitList(LinkList &L)
{
    L = (LinkList)malloc(sizeof (LNode));    //产生头结点，并使L指向头结点
    if(!L)
        return ERROR;
    L->next = NULL;
    return OK;
}//InitList

//销毁线性表L
Status DestroyList(LinkList &L)
{
    LinkList p;
    while(L)    //循环释放结点
    {
        p = L->next;
        free(L);
        L = p;
    }
    return OK;
}//DestroyList

//重置线性表L为空表
Status ClearList(LinkList L)
{
    LinkList p = L->next, q;
    while (p)    //循环释放结点
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = NULL;    //头结点指针域为空s
    return OK;
}//ClearLIst

//判断线性表是否为空表
Status ListEmpty(LinkList L)
{
    if(L->next)
        return true;    //非空返回OK
    else
        return false;    //空表返回ERROR
}//ListEmpty

//返回线性表L中的个数
int ListLength(LinkList L)
{
    int i = 0;
    LinkList p = L->next;    //p指向第一个结点
    while(p)    //循环到表尾
    {
        p = p->next;
        ++i;
    }
    return i;
}//ListLength

//当第i个元素存的时，赋值给e并返回OK，否则返回ERROR
Status GetElem(LinkList L, int i, ElemType &e)
{
    LinkList p = L->next;    //p指向第一个结点
    int j = 1;    
    while(p && j < i)        //顺指针向后查找，直到p指向第i个元素或p为空
    {
        p = p->next;
        ++j;
    }
    if(!p || (j > i))    //判断位置是否合法
        return ERROR;    
    e = p->data;            //取第i个元素
    return OK;
}//GetElem

//返回L中第一个与e满足compare()的数据元素的位序，诺不存在则返回ERROR
//compare()是数据元素判定函数
Status LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType,ElemType))
{
    int j = 0;
    LinkList p = L->next;
    while(p)
    {
        ++j;
        if(compare(p->data,e))
            return j;
        p = p->next;
    }
    return ERROR;
}//LocateElem

//若cur_e是L的数据元素，且不是第一个。则用pre_e返回他的前驱，
//否则操作失败，pre_e无定义
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e)
{
    LinkList p = L->next, q;    //p指向第一个结点
    while(p->next)    //p指的结点有后驱
    {
        q = p->next;    //q为p的后驱
        if(q->data == cur_e)
        {
            pre_e = p->data;    //获取前驱数据
            return OK;
        }
        p = q;
    }
    return ERROR;
}//PriorElem

//若cur_e是L的数据元素，且不是最后一个。则用next_e返回他的后驱，
//否则操作失败，next_e无定义
Status NextElem(LinkList L, ElemType cur_e, ElemType &next_e)
{
    LinkList p = L->next;
    while(p->next)
    {
        if(p->data == cur_e)
        {
            next_e = p->next->data;    //获取后驱数据
            return OK;
        }
        p = p->next;
    }
    return ERROR;
}//NextElem

//在第i个位置之前插入元素e
Status ListInsert(LinkList &L, int i, ElemType e)
{
    LinkList p = L;            //p指向第一个结点
    int j = 0;
    while (p && j < i-1)    //寻找第i-1个结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i-1)    //判断位置是否合法
        return ERROR;        
    LinkList s = (LinkList)malloc(sizeof (LNode));    //创建新结点                    
    //插入L中
    s->data = e;            
    s->next = p->next;
    p->next = s;
    return OK;
}//ListInsert

//删除第i个结点,并用e返回其值
Status ListDelete(LinkList &L, int i, ElemType &e)
{
    LinkList p = L;
    int j = 0;
    while (p->next && j < i-1)    //寻找i-1结点
    {
        p = p->next;
        ++j;
    }
    if(!(p->next) || j > i-1)    //位置不合理
        return ERROR;
    //删除结点并释放空间
    LinkList q = p->next;
    p->next = q->next;
    e = q->data;
    free(q);
    return OK;
}//ListDelete

//依次对L的每个元素调用函数Visit()，一旦失败，则操作失败
Status ListTraverse(LinkList L, void (*Visit)(ElemType))
{
    LinkList p = L->next;
    while(p)
    {
        Visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}//ListTraverse

//ListTraverse()调用的函数
void Visit(ElemType c)
{
    printf("%d ", c);
}//Visit

线性表的链式结构的基本操作函数的实现。
参考《数据结构（C语言版）》