线性表的链式存储结构

顺序表的缺点：
顺序表的最大问题是插入和删除需要移动大量的元素。

链式存储定义

为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后继的信息。

n个结点链接成一个链式线性表的结构叫做链表，当每个结点中只包含一个指针域时，叫做单链表。

链表的基本概念

表头结点
链表中的第一个结点，包含指向第一个数据元素的指针以及链表自身的一些信息，表头节点不是数据元素。

数据结点
链表中代表数据元素的结点，包含指向下一个数据元素的指针和数据元素的信息。

尾结点
链表中的最后一个数据结点，其下一元素指针为空，表示无后继

单链表示例：

单链表的实现

在C语言中可以用结构体来定义链表中的指针域

链表中的表头结点也可以用结构体实现

获取第pos个元素操作
判断线性表是否合法
判断位置是否合法
由表头开始通过next指针移动pos次后，当前元素的next指针即指向要获取的元素

插入元素到位置pos的算法
判断线性表是否合法
判断插入位置是否合法
由表头开始通过next指针移动pos次后，当前元素的next指针即指向要插入的位置
将新元素插入
线性表长度加1

删除第pos个元素的算法
判断线性表是否合法
判断插入位置是否合法
获取第pos个元素
将第pos个元素从链表中删除
线性表长度减1

//链表头文件 LinkList.h
#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
    LinkListNode* next;
};

LinkList* LinkList_Create();
void LinkList_Destroy(LinkList* list);
void LinkList_Clear(LinkList* list);
int LinkList_Length(LinkList* list);
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);
LinkListNode* LinkList_Get(LinkList* list, int pos);
LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

//链表的源文件 LinkList.h
#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;

struct Value   //此处结构体应当定义在main.c文件中
{
    LinkListNode header;
    int v;
};

LinkList* LinkList_Create() // O(1)  创建链表
{
    TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
    }    
    return ret;
}

void LinkList_Destroy(LinkList* list) // O(1) 销毁链表
{
    free(list);
}

void LinkList_Clear(LinkList* list) // O(1) 清空数据元素
{
    TLinkList* sList = (TLinkList*)list;  
    //因为数据封装，因此要使用头结点首先要类型转换  
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
    }
}

int LinkList_Length(LinkList* list) // O(1) 求链表当前的数据长度
{
    TLinkList* sList = (TLinkList*)list;
    int ret = -1;   
    if( sList != NULL )
    {
        ret = sList->length;
    }    
    return ret;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n) 插入数据
{ 
    TLinkList* sList = (TLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;    
    if( ret )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; (i<pos) && (current->next != NULL); i++)
        //此处还要判断插入位置是否超过了链表尾部
        {
            current = current->next;
        }        
        node->next = current->next;
        current->next = node;

        sList->length++;
    }    
    return ret;
}

LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n) 获取某个数据元素
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }       
        ret = current->next;
    }   
    return ret;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n) 删除某个数据元素
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }        
        ret = current->next;
        current->next = ret->next;

        sList->length--;
    }   
    return ret;
}

小结

链表的优点：
无需一次性定制链表的容量
插入和删除操作无需移动数据元素

链表的缺点：
数据元素必须保存后继元素的位置信息
获取指定数据的元素操作需要顺序访问之前的元素