数据结构 双向链表 C语言实现

 

dlist.h

#ifndef __dList_H
#define __dlist_H

typedef    int Item;
typedef struct Node *PNode;
typedef PNode Position;
/*定义节点类型*/
typedef struct Node
{
    Item data; /*数据域*/
    PNode previous; /*指向前驱*/
    PNode next;    /*指向后继*/
}Node;

/*定义链表类型*/
typedef struct
{
    PNode head; /*指向头节点*/
    PNode tail; /*指向尾节点*/
    int size;
}DList;


/*分配值为i的节点，并返回节点地址*/
Position MakeNode(Item i);
/*释放p所指的节点*/
void FreeNode(PNode p);
/*构造一个空的双向链表*/
DList* InitList();
/*摧毁一个双向链表*/
void DestroyList(DList *plist);
/*将一个链表置为空表，释放原链表节点空间*/
void ClearList(DList *plist);
/*返回头节点地址*/
Position GetHead(DList *plist);
/*返回尾节点地址*/
Position GetTail(DList *plist);
/*返回链表大小*/
int GetSize(DList *plist);
/*返回p的直接后继位置*/
Position GetNext(Position p);
/*返回p的直接前驱位置*/
Position GetPrevious(Position p);
/*将pnode所指节点插入第一个节点之前*/
PNode InsFirst(DList *plist,PNode pnode);
/*将链表第一个节点删除并返回其地址*/
PNode DelFirst(DList *plist);
/*获得节点的数据项*/
Item GetItem(Position p);
/*设置节点的数据项*/
void SetItem(Position p,Item i);
/*删除链表中的尾节点并返回其地址，改变链表的尾指针指向新的尾节点*/
PNode Remove(DList *plist);
/*在链表中p位置之前插入新节点S*/
PNode InsBefore(DList *plist,Position p,PNode s);
/*在链表中p位置之后插入新节点s*/
PNode InsAfter(DList *plist,Position p,PNode s);
/*返回在链表中第i个节点的位置*/
PNode LocatePos(DList *plist,int i);
/*依次对链表中每个元素调用函数visit()*/
void ListTraverse(DList *plist,void (*visit)());

#endif

dlist.c

#include"dlist.h"
#include<malloc.h>
#include<stdlib.h>
/*分配值为i的节点，并返回节点地址*/
Position MakeNode(Item i)
{
    PNode p = NULL;
    p = (PNode)malloc(sizeof(Node));
    if(p!=NULL)
    {
        p->data = i;
        p->previous = NULL;
        p->next = NULL;
    }
    return p;
}
/*释放p所指的节点*/
void FreeNode(PNode p)
{
     free(p);
}
/*构造一个空的双向链表*/
DList * InitList()
{
    DList *plist = (DList *)malloc(sizeof(DList));
    PNode head = MakeNode(0);
    if(plist!=NULL)
    {
        if(head!=NULL)
        {
            plist->head = head;
            plist->tail = head;
            plist->size = 0;
        }
        else
            return NULL;
    }
    return plist;
}

/*摧毁一个双向链表*/
void DestroyList(DList *plist)
{
    ClearList(plist);
    free(GetHead(plist));
    free(plist);
}

/*判断链表是否为空表*/
int IsEmpty(DList *plist)
{
    if(GetSize(plist) == 0 && GetTail(plist) == GetHead(plist))
        return 1;
    else
        return 0;
}
/*将一个链表置为空表，释放原链表节点空间*/
void ClearList(DList *plist)
{
    PNode temp,p;
    p = GetTail(plist);
    while(!IsEmpty(plist))
    {
        temp = GetPrevious(p);
        FreeNode(p);
        p = temp;
        plist->tail = temp;
        plist->size--;
    }
}

/*返回头节点地址*/
Position GetHead(DList *plist)
{
    return plist->head;
}

/*返回尾节点地址*/
Position GetTail(DList *plist)
{
    return plist->tail;
}

/*返回链表大小*/
int GetSize(DList *plist)
{
    return plist->size;
}

/*返回p的直接后继位置*/
Position GetNext(Position p)
{
    return p->next;
}

/*返回p的直接前驱位置*/
Position GetPrevious(Position p)
{
    return p->previous;
}

/*将pnode所指节点插入第一个节点之前*/
PNode InsFirst(DList *plist,PNode pnode)
{
    Position head = GetHead(plist);

    if(IsEmpty(plist))
        plist->tail = pnode;
    plist->size++;

    pnode->next = head->next;
    pnode->previous = head;

    if(head->next!=NULL)
        head->next->previous = pnode;
    head->next = pnode;

    return pnode;
}

/*将链表第一个节点删除,返回该节点的地址*/
PNode DelFirst(DList *plist)
{
    Position head = GetHead(plist);
    Position p=head->next;
    if(p!=NULL)
    {
        if(p==GetTail(plist))
            plist->tail = p->previous;
        head->next = p->next;
        head->next->previous = head;
        plist->size--;

    }
    return p;
}

/*获得节点的数据项*/
Item GetItem(Position p)
{
    return p->data;
}

/*设置节点的数据项*/
void SetItem(Position p,Item i)
{
    p->data = i;
}

/*删除链表中的尾节点并返回地址，改变链表的尾指针指向新的尾节点*/
PNode Remove(DList *plist)
{
    Position p=NULL;
    if(IsEmpty(plist))
        return NULL;
    else
    {
        p = GetTail(plist);
        p->previous->next = p->next;
        plist->tail = p->previous;
        plist->size--;
        return p;
    }
}
/*在链表中p位置之前插入新节点s*/
PNode InsBefore(DList *plist,Position p,PNode s)
{
    s->previous = p->previous;
    s->next = p;
    p->previous->next = s;
    p->previous = s;

    plist->size++;
    return s;
}
/*在链表中p位置之后插入新节点s*/
PNode InsAfter(DList *plist,Position p,PNode s)
{
    s->next = p->next;
    s->previous = p;

    if(p->next != NULL)
        p->next->previous = s;
    p->next = s;

    if(p == GetTail(plist))
        plist->tail = s;

    plist->size++;
    return s;
}

/*返回在链表中第i个节点的位置*/
PNode LocatePos(DList *plist,int i)
{
    int cnt = 0;
    Position p = GetHead(plist);
    if(i>GetSize(plist)||i<1)
        return NULL;

    while(++cnt<=i)
    {
        p=p->next;
    }

    return p;
}

/*依次对链表中每个元素调用函数visit()*/
void ListTraverse(DList *plist,void (*visit)())
{
    Position p = GetHead(plist);
    if(IsEmpty(plist))
        exit(0);
    else
    {

        while(p->next!=NULL)
        {
            p = p->next;
            visit(p->data);
        }
    }
}

test.c

#include"dlist.h"
#include<stdio.h>

void print(Item i)
{
    printf("数据项为%d 
",i);
}
int main()
{
    DList *plist = NULL;
    PNode p = NULL;

    plist = InitList();
    p = InsFirst(plist,MakeNode(1));
    InsBefore(plist,p,MakeNode(2));
    InsAfter(plist,p,MakeNode(3));

    printf("p前驱位置的值为%d
",GetItem(GetPrevious(p)));
    printf("p位置的值为%d
",GetItem(p));
    printf("p后继位置的值为%d
",GetItem(GetNext(p)));


    printf("遍历输出各节点数据项:
");
    ListTraverse(plist,print);
    printf("除了头节点该链表共有%d个节点
",GetSize(plist));
    FreeNode(DelFirst(plist));
    printf("删除第一个节点后重新遍历输出为:
");
    ListTraverse(plist,print);
    printf("除了头节点该链表共有%d个节点
",GetSize(plist));
    DestroyList(plist);
    printf("链表已被销毁
");
}

运行结果：

[walt740@localhost 02.Doublylinklist]$ gcc test.c dlist.c dlist.h -o test
[walt740@localhost 02.Doublylinklist]$ tree -L 2
.
├── dlist.c
├── dlist.h
├── test
├── test.c
└── 345217214345220221351223276350241250
    ├── bin
    ├── obj
    ├── 345217214345220221351223276350241250.cbp
    ├── 345217214345220221351223276350241250.depend
    └── 345217214345220221351223276350241250.layout

3 directories, 7 files
[walt740@localhost 02.Doublylinklist]$ ./test
p前驱位置的值为2
p位置的值为1
p后继位置的值为3
遍历输出各节点数据项:
数据项为2 
数据项为1 
数据项为3 
除了头节点该链表共有3个节点
删除第一个节点后重新遍历输出为:
数据项为1 
数据项为3 
除了头节点该链表共有2个节点
链表已被销毁
[walt740@localhost 02.Doublylinklist]$ ^

 转自 -- http://blog.csdn.net/hopeyouknow/article/details/6716177