linkList 简单链式链表的实现

链表实现的结构图

底层链表只需要有一个linkList就可以了，里面保存这指向第一个节点的指针，同时还有一个长度变量。

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

这个节点指针类型是linkListNode的结构体，结构体只有一个元素，一个指向自己的指针。

element 是一个结构体，包含了linkListNode结构体，同时包含了自己的其他信息。

typedef struct _Teacher
{
    LinkListNode node;
    char        name[32];
    int            age ;
}Teacher;

这样，使用一个TLinkList就可以将所有的数据元素串联起来了。

底层的操作库是不分配内存的，上层引用程序保证了内存的有效性。

// linkList.h
#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;

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

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 <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "linkList.h"

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


LinkList* LinkList_Create()  //O(1)
{
    TLinkList *tmp = NULL;

    tmp = (TLinkList *)malloc(sizeof(TLinkList));
    if (tmp == NULL)
    {
        printf("func LinkList_Create() err \n");
        return NULL;
    }
    memset(tmp, 0, sizeof(TLinkList));
    tmp->length = 0;
    tmp->header.next = NULL; //
    return tmp;
}

void LinkList_Destroy(LinkList* list)  //O(1)
{
    if (list == NULL)
    {
        return ;
    }
    free(list);
    return ;
}

void LinkList_Clear(LinkList* list)   //O(1)
{
    TLinkList *tList = NULL;
    tList = (TLinkList *)list;
    if (tList == NULL)
    {
        return ;
    }
    tList->header.next = NULL;
    tList->length = 0;

    return ;
}

int LinkList_Length(LinkList* list)  //O(1)
{
    TLinkList *tList = NULL;
    tList = (TLinkList *)list;
    if (tList == NULL)
    {
        return -1;
    }
    return tList->length;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)  //O(n)
{
    int                i = 0;
    LinkListNode    *current = NULL;
    TLinkList        *tList = NULL;

    tList = (TLinkList *)list;
    
    if (list==NULL || node==NULL || pos<0)
    {
        return -1;
    }

    current = &(tList->header);
    for (i=0; i<pos; i++)
    {
        current = current->next;
    }
    //新结点 连接 后继链表
    node->next = current->next;

    //前面的链表 连接 新结点
    current->next = node;

    tList->length ++;
    return 0;
}

LinkListNode* LinkList_Get(LinkList* list, int pos)  //O(n)
{
    int                i = 0;
    LinkListNode    *current = NULL;
    TLinkList        *tList = NULL;

    tList = (TLinkList *)list;

    if (list==NULL || pos < 0)
    {
        return NULL;
    }

    current = &(tList->header); //赋值指针变量初始化
    for (i=0; i<pos; i++)
    {
        current = current->next;
    }
    return current->next;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) //O(n)
{
    int                i = 0;
    LinkListNode    *current = NULL;
    LinkListNode    *ret = NULL;
    TLinkList        *tList = NULL;

    tList = (TLinkList *)list;
    if (list==NULL || pos<0)
    {
        return NULL;
    }

    current = &(tList->header);
    for (i=0; i<pos; i++)
    {
        current = current->next;
    }
    ret = current->next; //缓存要删除的结点

    current->next = ret->next;

    tList->length --;

    return ret;
｝