数据结构封装之《LinkList单向链表》

说明：

1. 该线性链表能够任意数量的数据，其实现方法通过地址链完成对所有插入数据的连接；
2. 该线性链表能够存储任何类型的数据，但要求数据类型为一个结构体，如下：
   　　struct Value
   　　{
   　　　LinkListNode header;
   　　　(任意类型) v;//这个就是要存储的数据
   　　}
3. 该链表有一个链表头，头部的LinkListNode指针指向第0个LinkListNode（数据从第0个下标开始算），同时链表头记录了已存储的数据个数；
4. 获取链表中的数据，需要对其数据类型进行转换。
5. 传入的参数LinkList实则是void类型，在函数内都需要类型转换成 TLinkList； 而传入的参数LinkListNode ，其实是一个含有一个指向LinkListNode 类型的指针成员的结构体，将其转换成Value 类型，就能够获取其存储的数据V。

下面将给出该数据结构的代码，每个函数的结构分析 ，以及个别主要函数的汇编分析

---

代码：

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.c

#include <stdio.h>`
#include <malloc.h>
#include "LinkList.h"

//这是链表头，header指向链表第0个元素，Length为链表当前长度；
typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;

//创建链表
LinkList* LinkList_Create() 
{
    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;
}

//插入值（pos从0开始）
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;
}

lmain.c

#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

//注意，这个结构体就是存入链表的元素，其中v可以为任意类型
struct Value
{
    LinkListNode header;
    int v;
};



int main(int argc, char *argv[]) 
{
    int i = 0;
    LinkList* list = LinkList_Create();

    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;

    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;

    LinkList_Insert(list, (LinkListNode*)&v1, LinkList_Length(list));
    LinkList_Insert(list, (LinkListNode*)&v2, LinkList_Length(list));
    LinkList_Insert(list, (LinkListNode*)&v3, LinkList_Length(list));
    LinkList_Insert(list, (LinkListNode*)&v4, LinkList_Length(list));
    LinkList_Insert(list, (LinkListNode*)&v5, LinkList_Length(list));

    for(i=0; i<LinkList_Length(list); i++)
    {
        struct Value* pv = (struct Value*)LinkList_Get(list, i);

        printf("%d\n", pv->v);
    }

    while( LinkList_Length(list) > 0 )
    {
        struct Value* pv = (struct Value*)LinkList_Delete(list, 0);

        printf("%d\n", pv->v);
    }

    LinkList_Destroy(list);

    return 0;
}

---

函数结构分析：

1.LinkList_Create

2.LinkList_Destroy

3.LinkList_Clear

4.LinkList_Length

5.LinkList_Insert

6.LinkList_Get

7.LinkList_Delete

---

汇编分析：

1.SeqList_Create

2.SeqList_Insert