双向链表代码

在单链表当中，从已知节点出发，只能访问该节点的后继节点，却无法访问

该节点之前的节点，在单循环链表当中，虽然可以通过一个节点访问表中所

有节点，但是要找到直接前驱却要遍历整个表，因此为了加快寻找某个节点

的前驱，可以在每个节点的结构体上添加一个直接访问前驱的指针域来快速

定位前驱节点。下面是简单的双链表代码，当然优势还没有体现出来，后面

在慢慢补充

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define OVERFLOW -1

typedef struct Dbnode{
  int data;
  struct Dbnode * next;
  struct Dbnode * prior;
} Dbnode, *Dblink;

typedef int ElemType;
typedef int Status;

/*********************
　　　　　初始化
输入：链表指针，初始个数
输出：状态码
功能：初始化带数值的双向链表
*********************/
Status initLink(Dblink * link,int num){
  srand(time(0));

  Dblink L = *link;
  Dblink tmp,new;
  L->data = 0;
  L->prior = NULL;
  L->next = NULL;
  tmp = L;

  int i;
  for(i=0;i<num;i++){
    new = (Dblink)malloc(sizeof(Dbnode));
    new->data = rand()%100 +1;
    new->next = tmp->next;
    new->prior = tmp;
    tmp->next = new;
    tmp = tmp->next;
  }

  tmp->next = *link; //connect the head
  (*link)->prior = tmp;
  return OK;
}

/*********************
　　　　　插入
输入：链表指针，插入位置，插入值
输出：状态码
功能：在指定的位置插入指定的值
*********************/
Status insertLink(Dblink *link,int index,ElemType e){

  Dblink tmp = (*link)->next;  //ignore head node
  Dblink new,pre;
  
  int i=1;
  
  while( tmp!=*link && i<index ){
     tmp = tmp->next;
     i++;
  }

  if( tmp==*link || i>index){
     printf("overflow
");
     return OVERFLOW;
  }

  new = (Dblink)malloc(sizeof(Dbnode));
  pre = tmp->prior;

  new->data = e;
  new->prior=pre;
  new->next =tmp;
  pre->next = new;
  tmp->prior= new;
  
  return OK;
}

/*********************
　　　　　删除
输入：链表指针，删除位置
输出：状态码
功能：在指定位置删除节点
*********************/
Status deleteLink(Dblink *link,int index){
  
  Dblink tmp = (*link)->next;  //ignore head node 

  int i=1;
  while( tmp!=*link && i<index ){
    tmp=tmp->next;
    i++;
  }
  
  if( tmp==*link || i>index ){
     printf("overflow
");
     return OVERFLOW;
  }

  Dblink pre = tmp->prior;
  Dblink net = tmp->next;
  pre->next = tmp->next;
  net->prior = tmp->prior;

  free(tmp);

  return OK;
}

/*********************
　　　　　颠倒
输入：链表指针
输出：状态码
功能：将链表的节点颠倒过来
*********************/
Status convertLink(Dblink * link){

  Dblink p,q;
  p = (*link)->next;
  
  while( p != *link){
    q = p->next;
    p->next = p->prior;
    p->prior = q;
    p=q;
  }

  q = (*link)->next; //p is *link
  (*link)->next = p->prior;
  (*link)->prior = q;
  
  return OK;
}

/*********************
　　　　　打印
输入：链表指针
输出：状态码
功能：将链表的元素一一打印
*********************/
Status printLink(Dblink link){
   Dblink p = link;
   while(p->next!=link){
     p = p->next;        //ignore head node
     printf("[%d] ",p->data);
   }

   printf("
");
   return OK;
}

int main(){
  int num,index,value;
  Dblink link = (Dblink)malloc(sizeof(Dbnode));

  //initation
  printf("[create]enter the num:");
  scanf("%d",&num);
  initLink(&link,num);
  printLink(link);

  //convert
  printf("[convert]
");
  convertLink(&link);
  printLink(link);

  //insert
  printf("[insert]enter the index:");
  scanf("%d",&index);
  printf("[insert]enter the value:");
  scanf("%d",&value);
  insertLink(&link,index,value);
  printLink(link);

  //delete
  printf("[delete]enter the index:");
  scanf("%d",&index);
  deleteLink(&link,index);
  printLink(link);
  return OK;
}