数据结构-双向链表

单链表的结点中只有一个指示直接后继的指针域，由此，从某个结点出发只能顺指针往后寻查其他结点。若要寻查结点的直接前驱，则需从表头指针出发。为克服单链表这种单向性的缺点，可利用双向链表。

在双向链表中的结点中有两个指针域，其一指向直接后继，另一指向直接前驱。

定义的辅助宏：

#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define LISTINCREMENT 10
#define LIST_INIT_SIZE 30000
typedef int Status;
typedef int ElemType;

双向链表的存储结构定义：

typedef struct DuLNode{
    ElemType data;
    struct DuLNode *next;
    struct DuLNode *prior;
}DuLNode,*DuLinkList;

初始化一个双链表.

Status InitList_DuL(DuLinkList &L){
    //初始化一个双链表
    L=(DuLNode *)malloc(sizeof(DuLNode));
    if(!L)
        exit(OVERFLOW);
    L->next=NULL;
    L->prior=NULL;
    return OK;
}

在带头结点的双链循环线性表L中第i个位置之前插入元素e

Status ListInsert_DuL(DuLinkList &L,int i,ElemType e){
//在带头结点的双链循环线性表L中第i个位置之前插入元素e
//i的合法值为 1 <=i <= 表长+1
//在L中确定插入位置指针p
  DuLNode *p=L;
  int j=0;
  while(p&&j<i-1){
      p=p->next;
      j++;
  }
  if(!p||i<1)
      return ERROR;
  DuLNode *s;
  s=(DuLNode *)malloc(sizeof(DuLNode));
  if(!s) 
      exit(OVERFLOW);
  s->data=e;
  s->prior=p;
  if(!(p->next)){
      p->next=s;
      s->next=NULL;
  }
  else{
      s->next=p->next;
      p->next->prior=s;
      p->next=s;
  }
  return OK;
}

删除带头结点的双链线性表L的第i个元素.

Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e){
	//删除带头结点的双链线性表L的第i个元素，i的合法值为
	//1<=i<=表长 在L中确定第i个元素的位置指针p p=NULL，即第i个元素不存在
    DuLNode *p=L;
    int j=0;
    while(p&&j<i){
	p=p->next;
        j++;
    }
    if(!p||i<1)
        return ERROR;
    e=p->data;
    if(p->next){
        p->prior->next=p->next;
        p->next->prior=p->prior;
    }
    else
        p->prior->next=NULL;
    free(p);
    p=NULL;
    return OK;
}