《数据结构与算法分析——C语言描述》ADT实现(NO.00) : 链表(Linked-List)

开始学习数据结构，使用的教材是机械工业出版社的《数据结构与算法分析——C语言描述》，计划将书中的ADT用C语言实现一遍，记录于此。下面是第一个最简单的结构——链表。

链表(Linked-List)，即最基本的数据结构——线性表的链式存储结构。比起顺序存储，其好处在于空间使用的灵活性，以及插入、删除操作的高效性。下面给出笔者的链表结构C语言实现。其中算法和细节部分定有可优化之处，欢迎大神指正。

 

 

// LinkedList.h
#ifndef _LINKEDLIST_H
#define _LINKEDLIST_H

#include 
#include 

struct _Node;
typedef struct _Node Node;
typedef Node *PtrToNode;
typedef PtrToNode List;

List CreateList();
List MakeEmpty(List L);
int IsEmpty(List L);
int IsLast(PtrToNode P, List L);
PtrToNode Find(ElementType X, List L);
void Delete(ElementType X, List L);
PtrToNode FindPrevious(ElementType X, List L);
void Insert(ElementType X, List L, PtrToNode P);
void DeleteList(List L);
ElementType Retrieve(PtrToNode P);

#endif

　　

// LinkedList.c
#include "LinkedList.h"

struct _Node
{
    struct _Node *Next;
    ElementType Element;
};

List CreateList()
{
    List ret;
    if ((ret = (List)malloc(sizeof(Node))) != 0)
    {
        ret->Next = NULL;
        return ret;
    }
    printf("Fail to create! The memory is full!\n\n");
    return 0;
}

List MakeEmpty(List L)
{
    DeleteList(L);
    L = CreateList();
    return L;
}

int IsEmpty(List L)
{
    return L->Next == NULL;
}

int IsLast(PtrToNode P, List L)
{
    while (L && L->Next)
        L = L->Next;
    return P == L;
}

PtrToNode Find(ElementType X, List L)
{
    L = L->Next;
    while (L && L->Element != X)
        L = L->Next;
    return L;
}

void Delete(ElementType X, List L)
{
    PtrToNode p, q;
    p = L->Next;
    q = L;
    while (p && p->Element != X)
    {
        p = p->Next;
        q = q->Next;
    }
    if (p)
    {
        q->Next = p->Next;
        free(p);
    }
}

PtrToNode FindPrevious(ElementType X, List L)
{
    while (L->Next && L->Next->Element != X)
    {
        L = L->Next;
    }
    if (L->Next)
        return L;
    else
        return NULL;
}

void Insert(ElementType X, List L, PtrToNode P)
{
    PtrToNode t = P->Next;
    if((P->Next = (PtrToNode)malloc(sizeof(Node))) == NULL)
    {
        printf("Fail to insert! The memory is full!\n\n");
        return;
    }
    P->Next->Element = X;
    P->Next->Next = t;
}

void DeleteList(List L)
{
    PtrToNode p, q;
    p = L->Next;
    while(p)
    {
        q = p;
        p = p->Next;
        free(q);
    }
    L->Next = NULL;
}

ElementType Retrieve(PtrToNode P)
{
    return P->Element;
}

　　

　

下面是一点简单的测试，由于链表结构并不复杂，且之前已有所接触，所以没有做复杂的测试样例验证正确性。

#include 
#include "LinkedList.h"

#define ElementType int

int main()
{
    List l = CreateList();
    print(l);
    printf("Is empty: %d\n", IsEmpty(l));
    Insert(2, l, l);
    Insert(3, l, l);
    Insert(5, l, l->Next);
    print(l);
    Delete(3, l);
    print(l);
    DeleteList(l);
    print(l);
    return 0;    
}

　　

　　

转载于:https://www.cnblogs.com/DrChuan/p/11266058.html