作为练习，做了个静态双向循环链表的头文件。欢迎大家拍砖，多提意见

我在dev-cpp上按照标准C的格式写的，并且简单的调试通过。

参考书是老严那本和Weiss那本《数据结构算法分析-C语言描述》
/*--------------------------------------------------------------------------------
使用前要定义LElemType ，如：
typedef int LElemType;
#include "staticlist.h"

创建链表之前应先对链表空间初始化，只需初始化一次,如：
InitListSpace();         //初始化链表空间
List list1=CreateList(); //创建链表1
List list2=CreateList(); //创建链表2

void InitListSpace()          //初始化
List CreateList(void)         //建立链表
void ClearList(List L)        //清空链表
void ReverseList(List L)      //反转链表
int IsListEmpty(List L)       //判表空
int GetListLen(List L)        //求表长
Position GetFirstPos(List L)       //求表首
Position GetLastPos(List L)        //求表尾
Position GetPriorPos(List L,Position P) //求前驱
Position GetNextPos(List L,Position P)  //求后继
Position LocList(List L,int n)               //定位第n个元素
Position OppLocList(List L,int n)            //逆向定位第n元
Position FindLElem(List L,LElemType e)       //查找e在表中的首个位置
Position OppFindLElem(List L,LElemType e)    //逆向查找
Position SrchLElem(List L,int(* judge)(LElemType))    //条件搜索
Position OppSrchLElem(List L,int(* judge)(LElemType)) //逆向条件搜索
LElemType ReadLElem(Position P)         //读结点元素值
void WriteLElem(Position P,LElemType e) //写结点元素值
void InsLElem(List L,Position P,LElemType e) //在P位置插入元素
void InsFirstLElem(List L,LElemType e)       //在表首插入元素
void InsLastLElem(List L,LElemType e)        //在表尾插入元素
void DelLElem(List L,Position P)             //删除结点
int TraList(List L,int (* visit)(LElemType))      //正向遍历
int OppTraList(List L,int (* visit)(LElemType))   //逆向遍历

作者  bpt
-------------------------------------------------------------------------------*/

#ifndef _staticlist_h
#define _staticlist_h

#define LIST_SPACE ( 1000 ) //链表空间大小
#define TRUE    ( 1 )
#define FALSE   ( 0 )

typedef int Position;
typedef Position List;
struct _Static_Double_List
{
     LElemType data;
     Position prior;
     Position next;
} ListSpace[LIST_SPACE];

Position CursorAlloc(void);
void CursorFree(Position P);

void InitListSpace()
{
     int i;

     for( i=0; i<LIST_SPACE-1; ++i )
     {
          ListSpace[i].next = i + 1;
     }
     ListSpace[i].next = 0;
}

List CreateList(void)
{
     Position P;

     P = CursorAlloc();
     ListSpace[P].next = P;
     ListSpace[P].prior = P;
     return P;
}

void ClearList(List L)
{
     Position P,Tmp;

     P = ListSpace[L].next;
     while( P!=L )
     {
          Tmp = P;
          P = ListSpace[P].next;
          CursorFree(Tmp);
     }
     ListSpace[L].next = ListSpace[L].prior = L;
     return;
}

void ReverseList(List L)
{
     Position cur,P;

     cur = L;
     while( (P=ListSpace[L].next)!=L )
     {
          ListSpace[L].next = ListSpace[P].next;
          ListSpace[cur].prior = P;
          ListSpace[P].next = cur;
          cur = P;
     }
     ListSpace[L].next = cur;
     return;
}

int IsListEmpty(List L)
{
     return ListSpace[L].next == L;
}

int GetListLen(List L)
{
     int i;
     Position P;

     P = L;
     i = 0;
     while(ListSpace[P].next!=L )
     {
          ++i;
          P = ListSpace[P].next;
     }
     return i;
}

Position GetFirstPos(List L)
{
     return ListSpace[L].next;
}

Position GetLastPos(List L)
{
     return ListSpace[L].prior;
}

Position GetPriorPos(List L,Position P)
{
     return ListSpace[P].prior;
}

Position GetNextPos(List L,Position P)
{
     return ListSpace[P].next;
}

Position LocList(List L,int n)
{
     int i;
     Position cur;

     cur = L;
     for(i=0; i<n && ListSpace[cur].next!=L; ++i)
     {
          cur = ListSpace[cur].next;
     }
     return cur;
}

Position OppLocList(List L,int n)
{
     int i;
     Position cur;

     cur = L;
     for(i=0; i<n && ListSpace[cur].prior!=L; ++i)
     {
          cur = ListSpace[cur].prior;
     }
     return cur;
}

Position FindLElem(List L,LElemType e)
{
     Position cur;

     cur = ListSpace[L].next;
     while( cur!=L && ListSpace[cur].data!=e )
     {
          cur = ListSpace[cur].next;
     }
     return cur;
}
Position OppFindLElem(List L,LElemType e)
{
     Position cur;

     cur = ListSpace[L].prior;
     while( cur!=L && ListSpace[cur].data!=e )
     {
          cur = ListSpace[cur].prior;
     }
     return cur;
}

Position SrchLElem(List L,int(* judge)(LElemType))
{
     Position cur;

     cur = ListSpace[L].next;
     while( cur!=L && !(* judge)(ListSpace[cur].data) )
     {
          cur = ListSpace[cur].next;
     }
     return cur;
}

Position OppSrchLElem(List L,int(* judge)(LElemType))
{
     Position cur;

     cur = ListSpace[L].prior;
     while( cur!=L && !(* judge)(ListSpace[cur].data) )
     {
          cur = ListSpace[cur].prior;
     }
     return cur;
}

LElemType ReadLElem(Position P)
{
     return ListSpace[P].data;
}

void WriteLElem(Position P,LElemType e)
{
     ListSpace[P].data = e;
     return;
}

void InsLElem(List L,Position P,LElemType e)
{
     Position Tmp;

     Tmp = CursorAlloc();
     ListSpace[Tmp].data = e;
     ListSpace[ListSpace[P].prior].next = Tmp;
     ListSpace[Tmp].prior = ListSpace[P].prior;
     ListSpace[P].prior = Tmp;
     ListSpace[Tmp].next = P;
     return;
}

void InsFirstLElem(List L,LElemType e)
{
     Position Tmp;

     Tmp = CursorAlloc();
     ListSpace[Tmp].data = e;
     ListSpace[ListSpace[L].next].prior = Tmp;
     ListSpace[Tmp].next = ListSpace[L].next;
     ListSpace[L].next = Tmp;
     ListSpace[Tmp].prior = L;
     return;
}

void InsLastLElem(List L,LElemType e)
{
     Position Tmp;

     Tmp = CursorAlloc();
     ListSpace[Tmp].data = e;
     ListSpace[ListSpace[L].prior].next = Tmp;
     ListSpace[Tmp].prior = ListSpace[L].prior;
     ListSpace[L].prior = Tmp;
     ListSpace[Tmp].next = L;
     return;
}

void DelLElem(List L,Position P)
{
     ListSpace[ListSpace[P].prior].next = ListSpace[P].next;
     ListSpace[ListSpace[P].next].prior = ListSpace[P].prior;
     CursorFree(P);
     return;
}

int TraList(List L,int (* visit)(LElemType))
{
     Position cur;

     cur = ListSpace[L].next;
     while( cur!=L )
     {
          if( !(* visit)(ListSpace[cur].data) )
          {
               return FALSE;
          }
          cur = ListSpace[cur].next;
     }
     return TRUE;
}

int OppTraList(List L,int (* visit)(LElemType))
{
     Position cur;

     cur = ListSpace[L].prior;
     while( cur!=L )
     {
          if( !(* visit)(ListSpace[cur].data) )
          {
               return FALSE;
          }
          cur = ListSpace[cur].prior;
     }
     return TRUE;
}

Position CursorAlloc(void)
{
     Position P;

     P = ListSpace[0].next;
     ListSpace[0].next = ListSpace[P].next;
     return P;
}

void CursorFree(Position P)
{
     ListSpace[P].next = ListSpace[0].next;
     ListSpace[0].next = P;
     return ;
}

#endif