C/C++版数据结构之链表<三>

    今天来讨论下链表中的双向链表。

双向链表：

      概念：在双向链表中，结点除含有数据域外，还含有两个指针域：一个存储直接后继结点的地址，称为右链域；另一个存储直接前驱结点的地址，称为左链域。

typedef struct node {     int num;              //数值域     struct node *lnext;   //左链域指针     struct node *rnect;   //右链域指针}stud;

      双向链表常用算法：

先对三个指针作个声明：

head：用来指向链表的头部。链表需要一个指针来标识，这就是头指针。

p1：用来指向新结点，以及用来遍历链表的每一个结点。

p2：用来指向当前结点。

（1）双向链表创建算法

创建结点数目为n的双向链表：

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
stud* Create(int n) {     stud *head,*p1,*p2;     head=p1=p2=NULL;     for(int i=0;i<n;i++)     {         p1=(stud*)malloc(sizeof(stud));         p1->num=i;         if(i==0)         {             head=p1;             head->lnext=NULL;         }         else         {             p2->rnext=p1             p1->lnext=p2;         }         p2=p1;             }     p2->rnext=null;     return head; }

（2）双向链表的查找算法

（一）头结点输入双向链表查找算法

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
stud* Find_FormHead(stud *head,int i) {     stud *p1;     p1=head;     while(p1!=NULL)     {         if(i==p1->num)         {             break;         }         else         {             p1=p1->rnext;   //遍历链表        }     }     return p1; }

（二）无序双向链表查找算法

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;

//p是链表中任一个结点指针，i是要查的号码
stud* Find_NoSort(stud *p,int i)  {     stud *p1;     p1=p;
    //先住右遍历    while(p1!=NULL)     {         if(i==p1->num)         {             break;         }         else         {             p1=p1->rnext;         }     }
    //往左遍历    if(p1==NULL)     {         p1=p;         while(p1!=NULL)         {             if(i==p1->num)             {                 break;             }             else             {                 p1=p1->lnext;             }         }     }     return p1;     }

（三）有序双向链表查找算法（从小到大）

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
stud* Find_IsSort(stud *p,int i) {     stud *p1;     p1=p;     while(p1!=NULL)     {         if(i==p1->num)         {             break;         }         else         {             if(i > p1->num)       //往右遍历            {                 p1=p1->rnext;             }             else             {                 p1=p1->lnext;    //往左遍历            }         }     }     return p1; }

（3）双向链表的删除算法

（一）头指针输入双向链表删除算法

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
bool Delete_FormHead(stud *head,int i) {     bool flag=false;     if(head)     {         stud *p1,*p2;         while(p1->num!=i && p1->rnext!=NULL)         {             p2=p1;             p1=p1->rnext;         }         if(p1->num==i)         {             if(p1==head)             {                 head=p1->rnext;             }             else             {                 p2->rnext=p1->rnext;             }             free(p1);   //释放已经脱离链表的结点内存            flag=true;         }     }     return flag; }

（二）无序双向链表删除算法

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
bool Delete_NoSort(stud *p,int i) {     bool flag=false;     if(p)     {         stud *p1,*p2;
        //往右遍历        while(p1!=NULL)         {             if(i==p1->num)             {                 break;             }             else             {                 p2=p1;                 p1=p1->rnext;             }         }                  //往左遍历        while(p1!=NULL)         {             if(i==p1->num)             {                 break;             }             else             {                 p2=p1;                 p1=p1->lnext;             }         }     }     if(p1->num == i)     {         if(p1=p)         {             p=p1->rnext;         }         else         {             p2->rnext=p1->rnext;         }         free(p1)         flag=true;     }     return flag; }

（三）有序双向链表删除算法

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
bool Delete_IsSort(stud *p,int i) {     bool flag=false;     if(p)     {         stud *p1,*p2;         while(p1->num!=i && p1!=NULL)         {             p2=p1;             if(i > p->num)          //往右遍历            {                 p1=p1->rnext;             }             else                    //往左遍历            {                 p1=p1->lnext;             }         }         if(p1->num==i)         {             if(p1==p)             {                 p=p1->rnext;             }             else             {                 p2->rnext=p1->rnext;             }             free(p1);       //释放已经脱离链表的结点内存            flag=true;         }     }     return flag; }

（4）双向链表的插入算法

（一）双向链表通用插入算法

说明：p0为输入的链表指针，p为插入的结点地址

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
stud *Insert(stud *p0,stud *p) {     stud *p1,*p2;     p1=p0;
    if(!p0)     {         p0=p;         p->rnext=NULL;         p->lnext-NULL;     }     else     {         //往右遍历        if(p->num > p1->num)              {             while(p->num > p1->num && p1->rnext!=NULL)             {                 p2=p1;                 p1=p1->rnext;             }
            if(p->num < p1->num)             {                 if(p0==p1)                 {                     p0=p;                 }                 else                 {                     p2->rnext=p;                     p->rnext=p1;                 }             }             else                //把p插入链表尾部            {                 p1->rnext=p;                 p->rnext=NULL;             }         }
        //往左遍历        else         {             while(p->num < p1->num && p1->lnext!=NULL)             {                 p2=p1;                 p1=p1->lnext;             }             if(p->num > p1->num)             {                 if(p0==p1)                 {                     p0=p;                 }                 else                 {                     p2->lnext=p;                     p->lnext=p1;                 }             }             else         //把这插入链表头部            {                 p1->lnext=p;                 p->lnext=NULL;             }         }     }     return p0; }

（二）头结点输入双向链表插入算法

typedef struct node {     int num;              //数值域    struct node *lnext;   //左链域指针    struct node *rnect;   //右链域指针}stud;
stud* Insert_FormHead(stud *head,stud *p) {     stud *p1,*p2;     p1=head;     if(!head)     {         head=p;         p->rnext=NULL;     }     else     {         while(p->num > p1->num && p1->rnext!=NULL)         {             p2=p1;             p1=p1->next;         }         if(p->num < p1->num)         {             if(head==p1)             {                 head=p;             }             else             {                 p2->rnext=p;                 p->rnext=NULL;             }         }         else             //将p插入链表尾部        {             p1->rnext=p;             p->rnext=NULL;         }         }     return head; }

诗意般生活 活出生命的精彩