静下心来写算法（之双向链表）

     据说Linux内核里广泛应用了一种叫做双向循环链表的东西，听起来很高端的样子，像是是双链表的头尾节点连在一起了，以后用空在研究吧。下面还是练习下今天的双向链表吧，先不循环了。

     双向链表比起单向链表貌似就是多了个前驱指针，使得对数据的操作更加方便了，可以方便的访问父节点而不用从头结点一个一个找了。但是代价还是不小的，每个结点都多出了4字节(32位系统上是这样的，其它平台还不清楚)的内存占用。

双向链表：1）在数据结构里有双向指针

                 2）插入或者删除数据时要注意前后结点指针方向的操作

1）双向表数据结构

typedef struct _DLNODE{
     int dat;
     struct _DLNODE *prev;
     struct _DLNODE *next;
}DLNODE;

2）创建结点

DLNODE *creat_node(int value)
{
     DLNODE *node;
     node=(DLNODE *)malloc(sizeof(DLNODE));
     assert(NULL!=node);
     node->dat=value;
     node->prev=NULL;
     node->next=NULL;
     return node;
}

3）在表尾添加节点

void add_node(DLNODE *head,int value)
{
     DLNODE *node=NULL;
     DLNODE *index=head;
     node=(DLNODE *)malloc(sizeof(DLNODE));
     assert(NULL!=node);
     while(NULL!=index->next){
          index=index->next;
     }
     node->dat=value;
     node->prev=index;
     node->next=NULL;
     index->next=node;
}

4）node节点后插入新的节点

void insert_node(DLNODE *node,int value)
{
     if(NULL==node)
          return;
     DLNODE *new_node=creat_node(value); 
     if(NULL==node->next){
          node->next=new_node;
          new_node->prev=node;
          new_node->next=NULL;
     }else{
          new_node->prev=node;
          new_node->next=node->next;
          node->next->prev=new_node;
          node->next=new_node;
     }
}

5）查找节点

DLNODE *find_data(DLNODE *head,int value)
{
     if(NULL==head)
          return NULL;
     DLNODE *index=head;
     while(index->next!=NULL && index->dat!=value){
          index=index->next;
     }
     if(index->dat=value)
          return index;
     else
          return NULL;
    
}

6）删除节点,m为中心节点，p为前一节点，n为下一节点

void delete_data(DLNODE *head,int value)
{
     DLNODE *p=NULL,*n=NULL,*m=NULL;
     m=find_data(head,value);
     n=m->next;
     p=m->prev;
     p->next=n;
     n->prev=p;
     free(m);
}

7）获取链表长度

int get_length(DLNODE *p)
{
     if(NULL==p){
          return 0;
     }else{
          return get_length(p->next)+1;
     }
}

8）打印数据

void print_node(DLNODE *p)
{
     if(p){
          printf("%d\t",p->dat);
          print_node(p->next);
     }
}

有时候明明感觉代码没有问题，可是就是运行不了，编译器不报错，调试也直接通过，然后整个人就接近崩溃的边缘了

仅仅是因为malloc(sizeof(DLNODE));写成了malloc(sizeof( int));怪不得一些高级语言都没指针了，手动管理内存太危险了。。。

处理链表有一种穿针引线的感觉，跟裁缝一样，把一块块的内存缝在一起，挺好玩的