数据结构——双向链表 与 循环链表

一.双向链表

1.相关概念理解

        双向链表和单向表的区别：每个节点不但有指向下一节点的next指针，还有指向上一节点的front指针。

单向表特点：只能从头遍历到尾

双向表特点：既可以从头遍历到尾，又可以从尾遍历到头。

但双向表有着操作上的缺点：

                                        ①每次在插入或删除节点操作时，相较于单向表非常麻烦

                                        ②双向表的内存空间占用更大，消耗空间更多

2.双向链表操作：

①定义链表：

        指针域：front，next

        数据域：相关元素数据

typedef struct student{
    int num,id;
    char name[101];
    struct student *next;
    struct student *front;
}student; 

②双向链表的创建

双向链表的创建相较于单向链表，多了有关 front指针的操作 

        1.创建头节点时，将头节点front和next指针赋值为NULL

        2.当有新节点创建时，新节点的front指针指向原来的尾节点。

void  link_add(student **phead,student *pnew) // 创建双向链表
{
    student *pmov=*phead; 
    if(*phead==NULL) // 起始点为空，则第一个输入数据为起始节点
    {
        *phead=pnew;
        pnew->front=NULL;
        pnew->next=NULL;
    }
    else
    {
        while((*pmov).next!=NULL)   {pmov=pmov->next;} // 指针操作
        pmov->next=pnew; //移动到当前尾节点  当前节点next即为新节点
        pnew->front=pmov; // 新节点的front 
        pnew->next=NULL;
    }
}

③双向链表的插入

1.插入在头节点前时：将新节点的next赋为当前头节点pb，front 赋为NULL

                                    当前头节点pb的 front 指针指向新节点，最后将 phead 指针赋为 新节点

2.插入在中间元素pf pb 之间时，pf的next指针指向新节点，新节点的front指针指向pf

                                                    pb的front指针指向新节点，新节点的next指针指向pb

3.插入在尾节点时 尾节点pb的next 赋为 新节点 新节点的front 赋为 pb  next 赋为 NULL

void link_insert(student **phead,student *pnew)
{
    student *pf=*phead,*pb=*phead;
    if(*phead==NULL) //如果链表为空，建立一头节点
    {
        *phead=pnew;
        pnew->next=NULL;
        pnew->front=NULL; 
        return ;
    }
    while(pnew->num>=pb->num && pb->next != NULL) // 遍历链表，直至找到插入位置
    {
        pf=pb;       // pnew将插入在 pf 和 pb 之间 
        pb=pb->next;
    }
    if(pnew->num<pb->num) // 成功找到
    { 
        if(pb==*phead) // 如果此时pb为头节点
        {
            pnew->next=pb; // 将头节点转移至 pnew
            pnew->front=NULL; 
			pb->front=pnew; //将原头节点的front指向新头节点 
            *phead=pnew;
        }
        else // 此时为中间位置 
        {
            pf->next=pnew;
            pnew->front=pf; 
            pnew->next=pb;
            pb->front=pnew;
        }
    }
    else // 此时将节点插入在链表尾端
    {
        pb->next=pnew;
        pnew->front=pb;
        pnew->next=NULL;
    }
}

④双向链表的删除

 1.当删除节点为头节点时，分为两种情况

                a.只有一个头节点：则直接将*phead指针向next移动

                b.还有多个节点：将*phead指针向next移动，并且将front赋为空

2.当删除中间节点时，则直接将pf的next指针指向pb的next指针

                                 pb的next指针的front直接指向 pf

3.删除尾节点时，直接将pf的next赋值为空

void link_delete(student **phead,int num) // 删除链表节点
{
    student *pb=*phead,*pf=*phead;
    if(*phead==NULL) {return ;}
    while(pb->num!=num && pb->next!=NULL)
    {
        pf=pb; 
        pb=pb->next;
    }
    if(pb->num==num) //pf 为 pb（需要删除的节点的前一个节点）
    {
        if(pb==*phead) // 若需要删除的点为头节点 则只需要将头节点向next移动
        {
        	if((*phead)->next==NULL) // 只有一个节点时 
            	*phead=pb->next;
        	else   // 若有多个节点，需要将头节点的front指针赋为空 
			{
				*phead=pb->next;
				(*phead)->front=NULL;	
			} 
		}
        else
        {
        	if(pb->next!=NULL)
			{
				pf->next=pb->next; // 否则pf的next 为 删除节点的next
				(pb->next)->front=pf;
			}
            else // 删除尾节点 直接将pf的next赋为空 
            {
            	pf->next=NULL;
			}
        }
    }
    return ;
}

⑤双向链表的查找和遍历

 与单向链表一样，只是可以从尾节点遍历到头节点（逆向） front指针

void link_print(student *head) // 遍历链表
{
    student *pmov=head,*pmov2;
    while(pmov!=NULL)
    {
        printf("%d %d \n",pmov->id,pmov->num);
        if(pmov->next==NULL) 
		{
			pmov2=pmov;
			pmov=pmov->next;
		}
		else pmov=pmov->next;
    }
    while(pmov2!=NULL)
    {
    	printf("%d %d \n",pmov2->id,pmov2->num);
    	pmov2=pmov2->front;
	}
    return ;
}

二.循环链表

与单向链表区别，单向链表的尾节点连接到了头节点，如图所示

操作的方法：可在每一次链表创建时，将当前的尾节点next指针指向phead指针头节点，当下一次创建新节点时，该节点的next指针将被覆盖为新节点，以此类推，除尾节点的每一个节点next指针都将重新被新节点覆盖，不会出现错误。

需要注意的是，单向链表与循环链表大部分操作相同，当对头节点操作时，才会有所不同

①循环链表的创建

void link_add(student **phead,student *pnew) 
{
    student *pmov=*phead;
    if(*phead==NULL)
    {
        *phead=pnew;
        pnew->next=*phead;
    }
    else
    {
        while((*pmov).next!=*phead)   {pmov=pmov->next;} 
        pmov->next=pnew;
        (*pnew).next=*phead; //区别在此 
    }
}

②循环链表的删除

void link_delete(student **phead,int num)
{
    student *pb=*phead,*pf=*phead;
    if(*phead==NULL) {return ;}
    while(pb->num!=num && pb->next!=*phead)
    {
        pf=pb; 
        pb=pb->next;
    }
    if(pb->num==num)
    {
        if(pb==*phead) // 当删除头节点时，需要将尾节点next指针指向新的头节点 
        {
            *phead=pb->next;
			student *pmov=*phead;
			while((*pmov).next!=pb)   {pmov=pmov->next;} // 可以选择遍历到尾端，或者设立一个尾指针 
			pmov->next=*phead;
        }
        else // 若删除尾节点或中间节点，原理相同 
        {
            pf->next=pb->next;
        }
    }
    return ;
}

③关于循环链表的应用

 

围成一个圈，即相当于循环链表，当报数出列时，即为删除该节点

 

#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
typedef struct student{
    int num,id;
    char name[101];
    struct student *next;
}student;
void link_add(student **phead,student *pnew) 
{
    student *pmov=*phead;
    if(*phead==NULL)
    {
        *phead=pnew;
        pnew->next=*phead;
    }
    else
    {
        while((*pmov).next!=*phead)   {pmov=pmov->next;} 
        pmov->next=pnew;
        (*pnew).next=*phead; //区别在此 
    }
}
void link_delete(student **phead,int num)
{
    student *pb=*phead,*pf=*phead;
    if(*phead==NULL) {return ;}
    while(pb->num!=num && pb->next!=*phead)
    {
        pf=pb; 
        pb=pb->next;
    }
    if(pb->num==num)
    {
        if(pb==*phead) // 当删除头节点时，需要将尾节点next指针指向新的头节点 
        {
            *phead=pb->next;
			student *pmov=*phead;
			while((*pmov).next!=pb)   {pmov=pmov->next;} // 可以选择遍历到尾端，或者设立一个尾指针 
			pmov->next=*phead;
        }
        else // 若删除尾节点或中间节点，原理相同 
        {
            pf->next=pb->next;
        }
    }
    return ;
}
void pd(student **phead,int x)
{
	student *pb=(*phead);
	while((*phead)->next!=*phead)
	{
		student *pf=pb;
		for(int i=1;i<x;i++)
			pf=pf->next;
		pb=pf->next;
		link_delete(phead,pf->num);
	}
	printf("%d",(*phead)->num);
}
int main()
{
    student *head=NULL,*pnew=NULL;
    int n,m; scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        pnew=(student *)malloc(sizeof(student));
		pnew->num=i;
        link_add(&head,pnew);
    }
	pd(&head,m);
    return 0;
}