数据结构之双向链表

　　所谓双向链表，就是链表可以从两个方向进行遍历，有了对单向链表的了解，想要创建一个双向链表就是相对容易很多。来看看《数据结构与算法分析--C语言描述》这本书上咋说的。原文：有时候以倒叙的方式扫描链表很有用，标准的实现方法（单向链表）对此无能为力，然而解决方法却很简单，只要在数据结构上附加一个域，使它包含指向前一个单元的指针即可。其开销是一个附加的链，它增加了空间的需求，同时也使得插入和删除的操作的开销增加一倍，因为有更多的指针需要定位。另一方面，它简化了删除的操作，因为你不再被迫使用一个指向前驱单元的指针来访问这个关键字，这个信息是现成的。来看看在单向链表中删除一个元素的操作，首先需要找到被删除元素的前面一个节点，然后使这个节点指向被删除节点的后面一个节点，然后再删除这个节点。

　　看一下使用AutoCAD画出的双向链表的结构图。

　　一个对称的完整的结构！

下面是我其实现程序。

#ifndef DLIST_H_
#define DLIST_H_

typedef int ElementType;
typedef struct Node* PtrToNode;
typedef PtrToNode Dlist;
typedef PtrToNode Position;

Dlist CreateDlist();
int IsEmpty();
void Insert(ElementType X,Dlist L,Position P);
void Delete(ElementType X,Dlist L);
Position Find(ElementType X,Dlist L);
void MakeEmpty(Dlist L);
void PrintDlist(Dlist L);
void PrintDlist(Dlist L);//just for pratice
#endif

#include<stdlib.h>
#include"doublelist.h"

struct Node
{
    ElementType data;
    Position Forward;
    Position Next;
};


Dlist CreateDlist()
{
    Dlist L = malloc(sizeof(struct Node));//create header
    
    L->Forward = NULL;
    L->Next = NULL;
    
    return L;
}

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

Position Find(ElementType X, Dlist L)
{
    Position P ;
    P = L->Next;
    while(P != NULL && P->data != X)
        P = P->Next;
    return P;
}

void Delete(ElementType X, Dlist L)
{
    Position P = Find(X,L);
    if( P != NULL)
    {
        P->Forward->Next = P->Next;
        P->Next->Forward = P->Forward;
        free(P);
    }
}

void MakeEmpty(Dlist L)
{
    Position P,Tmp;
    P = L->Next;
    while(P != NULL)
    {
        Tmp = P->Next;
        free(P);
        P = Tmp->Next;
    }
}


void PrintDlist(Dlist L)
{
    Position P;
    P = L->Next;
    while(P != NULL)
    {
        printf("%d ",P->data);
        P = P->Next; 
    }
}

void PrintDlistReve(Dlist L) // just for prarice
{
    Position P;
    P = L->Next;
    while(P->Next != NULL)
    {
        P = P->Next;
    }
    while(P->Forward != NULL)
    {
        printf("%d ",P->data);
        P = P->Forward;
    }
    
    
}

void Insert(ElementType X,Dlist L,Position P)
{
    Position Tmp = malloc(sizeof(struct Node));
    Tmp->data = X;
    
    if(P->Next != NULL)
    {
        Tmp->Next = P->Next;
        P->Next->Forward = Tmp;
        P->Next = Tmp;
        Tmp->Forward = P;
    }
    else
    {
        P->Next = Tmp;
        Tmp->Forward = P;
        Tmp->Next = NULL;
    }
    
}

下面是简单的测试：

　　

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

int main()
{
    Dlist L = CreateDlist();
    printf("Is List empty? %d
",IsEmpty(L));
    int i;
    for( i = 0;i<10;i++)
        Insert(i,L,L);
    printf("After Insert 0-9,is it empty? %d
",IsEmpty(L));
    printf("List contains: 
");
    PrintDlist(L);
    printf("
Print double list inverse:
");
    PrintDlistReve(L);
    return 0;
}

上面就是测试结果，感觉有点栈的意思了。