线性表——链式存储

链式存储

数据域：存储数据元素信息的域；指针域： 存储信息的域；

节点： 这两部分信息组成数据元素ai的存储映像，成为结点(Node)单链表：n个节点链结成一个链表，即为线性表的链式存储结构，因为此链表的每个节点中只含一个指针域，所以成为单链表。

头指针： 链表中第一个结点的存储位置；头节点： 为了更加方便的操作，我们在链表的第一个节点前附设一个节点，成为头节点(此时头指针存储的就是该节点的位置) ，一般此结点存储线性表的长度等附加信息，头节点的指针域存储指向第一个结点的指针

代码实现：

/*线性表的单链表存储结构*/
typedef struct Node
{
    ElemType data;
    struct Node *next;
} Node;
typedef struct Node *LinkList;   /*定义LinkList*/

单链表的读取

算法思路：

• 声明一个指针p指向链表第一个结点，初始化j从1开始；
• 当j<1时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；
• 若到链表末尾p为空，则说明第i个结点不存在；
• 否则查找成功，返回结点p的数据。

代码实现：

/*初始条件：顺序线性表L已存在*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;
    p = L->next;
    j = 1;
    while(p && j<i)
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i )
        return false;
    *e = p->data;
    return True;
}

单链表的插入与删除

算法思路:

1. 声明一指针p指向链表头节点，初始化j从1开始；
2. 当j<i时，就遍历链表，让p的指针向后移动，不断的指向下一结点，j累计+1；
3. 若到链表末尾p为空，则说明第i个结点不存在；
4. 否则查找成功，在系统中生成一个空结点；
5. 将数据元素e赋值给s->data；
6. 单链表的插入标准语句： s->next = p->next; p->next = s;
7. 返回成功。

代码实现：

Status ListInsert(LinkList *L, int i, ElemType e)
{
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    while(p && j < i)
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i)
        return False;
    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return True;        
}

删除类似，自行分析

单链表的整表创建

算法思路：

1. 声明一指针p和计数器变量i；
2. 初始化一空链表；
3. 让L的头节点的指针指向NULL，即建立一个带头节点的单链表；
4. 循环：
   生成一个新结点赋值给p；
   随机生成一数字赋值给p的数据域p->data;
   将p插入到头结点与前一新结点之间

代码实现：

/*随机产生n个元素的值，建立带表头结点的单链线性表L(头插法)*/
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;
    srand(time(0));
    *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;
    }
}
/*尾插法*/
void CreateListHead(LinkList *L, int n)
{
    LinkList p,r;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;
    for(i=0; i<n; i++)
    {
        p = (Node*)malloc(sizeof(Node));
        p->data =rand()%100+1;
        r->next = p;
        r = p;
    }
    r->next = NULL;
}

单链表的整表删除

算法思路：

1. 声明一结点p和q；
2. 将第一个结点赋值给p；
3. 循环：
   将下一个结点赋值给p；
   释放p；
   将q赋值给p。

代码实现：

Status ClearList(LinkList *L)
{
    LinkList p,q;
    p = (*L)->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;
    return True;
}

单链表结构与顺序存储结构优缺点

存储分配方式

• 顺序存储结构采用一段连续的存储单元依次存储线性表的数据元素
• 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素

时间性能：

• 查找
  顺序存储为 O(1)
  单链表为 O(n)
• 插入和删除
  顺序存储结构需要平均移动表长一半的元素，时间为 O(n)
  单链表在指出某个位置的指针后，插入和删除的时间仅为 O(1)

空间性能：

• 顺序存储结构需要预先分配存储空间，分大了，浪费，小了，容易溢出
• 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限

summer: 根据我们的需求，合理的选用顺序存储还是单链表