双链表相关资料

转载自http://blog.sina.com.cn/s/blog_65380c300100ij1s.html

双链表

(2010-04-25 21:42:44)

转载▼

标签：

杂谈

分类：C/C++

双向链表

双向链表中，每个结点都有两个指针域，一个指向其后继结点，另一个指针指向其前驱结点，如图1.1(a)所示，因此，可以从某个结点开始朝两个方向遍历整个链表。

如果循环链表中每个结点都采用双向指针就构成了双向循环链表。图1.1(c)所示就是一个带头结点的双向循环链表，其尾结点的后继指针指向表的头结点，而表头结点的前驱指针指向表的尾结点。空的双向循环链表的结构如图1.1(b)所示。




双向链表中结点的类型定义如下:

typedef int datatype;

typedef struct node *ptNode;

struct note{  

                     
    datatypedata;                    
    ptNodeproir,next;             
};

双链表是一种对称的结构，既有向前链又有向后链，这就使得双链表的前插和后插及自身删除操作都很方便，只需要修改几个结点的指针域，而不必进行大量的数据交换或遍历操作。下面给出双向链表的插入和删除运算的算法。

1 双向链表的前插运算

在双链表中某个给定的结点P之前插入一个新结点S，其操作步骤如下：

1）。将结点S的后继指向P本身；
2）。将结点S的前驱指向结点P的前驱所指向的结点；
3）。将结点P的前驱结点的后继修改为指向新结点S；
4）。将结点P的前驱修改为指向结点S本身；

插入新结点的过程如图1.2 (a)图所示。

双链表中在结点P之前插入一个新结点S的算法如下：

ptNode Insert_before(ptNode head,ptNode  p, intx)
{
       ptNode s;
       s=(ptNode)malloc(sizeof(node));//建立新结点
       s->data=x;                                    //将x的值赋给s->data
      s->next=p;                                    //1)将新结点S的后继指向结点P
       s->prior=p->prior;                       //2)将新结点S的前驱指向原结点P的前驱
       p->prior->next=s;                        //3)原结点P前驱结点的后继指向新结点S
       p->prior=s;                                   //4)原结点P的前驱指向新结点S
       return(head);                                //返回带头结点双链表的头指针
}

2 双向链表的后插运算

假设双链表中结点P的后继结点为Q，在结点P之后插入一个新结点S，其操作步骤如下：

1）。将结点S的前驱指向P本身；
2）。将结点S的后继指向结点P所指向的后继结点；
3）。将结点P的后继结点Q的前驱结点修改为新结点S本身；
4）。将结点P的后继结点修改为结点S本身；

插入新结点的过程如图1.2 (b)图所示。
双链表中在结点P之后插入一个新结点S的算法如下：

ptNode Insert_after(ptNode head,ptNode  p, intx)
{
       ptNode s;
       s=(ptNode)malloc(sizeof(node));//建立新结点
       s->data=x;                                    //将x的值赋给s->data
      s->next=p->next;                        //1)将新结点S的后继指向结点P的后继
       s->prior=p;                                  //2)将新结点S的前驱指向原结点P
       p->next->prior=s;                        //3)原结点P的后继结点的前驱指向新结点S
       p->next=s;                                   //4)原结点P的后继指向新结点S
       return(head);                                //返回带头结点双链表的头指针
}

3 双向链表的自身删除运算

假设双链表中某给定结点P的前驱结点为Q,其后继结点为S,则双链表中删除结点P的步骤如下:

1）。将结点P的前驱结点Q的后继结点指向结点P的后继结点S；
2）。将结点P的后继结点S的前驱结点指向结点Q；

插入新结点的过程如图1.2 (c)图所示。
在双链表中删除某个结点P自身的算法如下:

ptNode delete_node(ptNode head,ptNode p)
{
     if(p!=NULL)
     {
         p->prior->next=p->next;
         p->next->prior=p->prior;
         free(p);
         return(head);
     }
     else
     {
        return(NULL);
     }
}

由此可见，自身删除前后被删除的指针并没有改变，只是它后一个结点的向前指针和前一个结点的向后指针发生了变化，不再指向此结点。

这三种运算过程中，指针的变化情况分别如1.2 (a)、(b)、(c)图所示。

图1.2双向循环链表的前插、后插和自身删除操作示意图

完整的双向循环链表的操作:查询、删除、显示、插入 C程序在VC上验证通过：


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define N 10
typedef struct node *ptNode;
structnode{   
    charname[20];   
    ptNodeprior,next;
};



ptNode Creat(int n)
{   
    ptNodehead,ptr,newnode;  
    inti;   
   if((head=(ptNode)malloc(sizeof(node))) ==NULL)  
   {       
      printf("分配内存失败!\n");       
      exit(0);   
   }   
   strcpy(head->name,"head");
   //head->name[0] ='\0';//头结点初始化 
   head->prior =NULL;   
   head->next =NULL;   
    ptr =head;  
    for(i=0;i<n;i++)   
   {          
      if((newnode=(ptNode) malloc(sizeof(node))) ==NULL)      
      {           
         printf("cannot findspace!\n");           
         exit(0);      
      }       
      ptr->next=newnode;//连接新结点      
      printf("Please input the %d man's name:",i+1);      
      scanf("%s",newnode->name);       
      newnode->prior =ptr;//定义newnode的连接关系       
      newnode->next =NULL;      
       ptr =newnode;   
    }//endfor   
   head->prior =newnode;  
   ptr->next =head;  
   return(head);
}


ptNode Search(ptNode head,char *pEle)
{  
    ptNodeptr;  
    char*pTemp;   
    ptr =head->next;   
    while(ptr !=head)//以是否回到头结点为结束条件  
   {       
       pTemp =ptr->name;//pTemp暂存结点的名字地址     
      if(strcmp(pTemp,pEle) ==0)       
      {         
         return(ptr);       
      }       
      else        
      {           
          ptr =ptr->next;//指向下一结点      
      }   
   }   
   printf("查找不到数据!\n");   
    returnNULL;
}
//在选定名字前插入
void Insert_before(ptNode head,char *priorEle,char*insertEle)
{      
    ptNodeptr,newnode;   
   if((ptr=Search(head,priorEle))==NULL)  
   {       
      printf("Can't find the data toinsert!\n");       
      exit(0);   
   }   
   if((newnode=(ptNode)malloc(sizeof(node))) ==NULL)  
   {      
      printf("分配内存失败!\n");      
      exit(0);   
   }   
   strcpy(newnode->name,insertEle);//给新结点加载值  
   newnode->prior =ptr->prior;//前指针指向前结点,先处理以新结点为中心前后关系   
   newnode->next =ptr;//新结点后指针指向定位结点   
   (ptr->prior)->next =newnode;//前结点的由指针指向新结点   
   ptr->prior =newnode;   
}

//在选定名字后插入
void Insert_after(ptNode head,char *p,char *insertEle)
{      
    ptNodeptr,newnode;   
   if((ptr=Search(head,p))==NULL)  
   {       
      printf("Can't find the data toinsert!\n");       
      exit(0);   
   }   
   if((newnode=(ptNode)malloc(sizeof(node))) ==NULL)  
   {      
      printf("分配内存失败!\n");      
      exit(0);   
   }   
   strcpy(newnode->name,insertEle);//给新结点加载值  
   newnode->prior=ptr;
   newnode->next=ptr->next;
   ptr->next->prior=newnode;
   ptr->next=newnode;
}

void Print(ptNode head)
{   
    ptNodeptr;  
    ptr =head->next;  
   //printf("\n正向循环双链表为:\n");   
    while(ptr !=head)  
    //while(ptr!= NULL) 
   {       
       printf("%s",ptr->name);      
       ptr =ptr->next;   
   }   
   printf("\n");
}
void opposite(ptNode head)//反向输出
{
    ptNodeptr;
   ptr=head->next;
   while(ptr->next!=head)
     ptr=ptr->next;
   //printf("\n反向循环双链表为:\n");
   while(ptr!=head)
    {
      printf("%s",ptr->name);
     ptr=ptr->prior;
    }
   printf("\n");
}

void Delete(ptNode ptr)
{   
   (ptr->next)->prior =ptr->prior;//(ptr->next)->prior下一结点的左指针被赋前指针  
   (ptr->prior)->next =ptr->next;   
    free(ptr);
}



void main(void)
{   
    intnumber;   
    charstudName[20];  
    charinsertName[20];   
    ptNodehead,searchpoint; 
    intflag=1;
    charj;
    //number =N;   
   puts("输入双链表的最大结点数:");  
   scanf("%d",&number);   
    head =Creat(number);
   Print(head);  
   opposite(head);
   while(flag)
    {printf("请选择:\n");
     printf("1.显示所有元素\n");
     printf("2.删除一个元素\n");
     printf("3.元素前插入一个元素\n");
     printf("4.元素后插入一个元素\n");
     printf("5.退出程序   \n");
     scanf(" %c",&j);
     switch(j)
     {
       case'1':
         printf("\n正向循环双链表为:\n"); 
         Print(head);
         printf("\n反向循环双链表为:\n");
         opposite(head);
          break;
       case'2':
         printf("\n输入要删除的数据:\n");
          scanf("%s",studName);   
          searchpoint= Search(head,studName);
         Delete(searchpoint);
         printf("\n删除后的链表为:\n");
         Print(head); 
        break;
       case'3':
          printf("在双链表中指定一个元素的名字和要插入的数据(如aabb):\n");  
         //scanf("%s",studName);   
         //printf("输入想要插入的数据:\n");   
         scanf("%s%s",studName,insertName);   
         Insert_before(head,studName,insertName);  
         Print(head); 
        break;
       case'4':
          printf("在双链表中指定一个元素的名字和要插入的数据(如aabb):\n");   
         //scanf("%s",studName);   
         //printf("输入想要插入的数据:\n");   
         scanf("%s%s",studName,insertName);   
         Insert_after(head,studName,insertName);  
         Print(head); 
        break;
      default:
       flag=0;
       printf("程序结束，按任意键退出!\n");
     }
    }
   getch();
}