【链表】带头结点的双向循环链表

最新推荐文章于 2023-08-25 22:10:45 发布
最新推荐文章于 2023-08-25 22:10:45 发布
阅读量381 收藏
点赞数
分类专栏： C/C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42438771/article/details/87467051
版权

还需改进：

creat_node这个函数应有返回类型，来判断新建结点是否成功，不然主函数中不管成不成功都会访问该节点成员。

改了这个函数，在主函数中create_node后要判断是否成功，不成功就提示并退出函数，退出前别忘了还要释放链表！

同时create_link这个函数中也要判断head是否申请成功，不成功的话同样提示并退出函数。

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

struct dnode
{
    int num;

    struct dnode * prior;
    struct dnode * next;
};

typedef struct dnode Dnode;
typedef struct dnode * Dlink;

void create_dnode(Dlink *DblNode)
{
    int count = 10;

    do
    {
        *DblNode = (Dlink)malloc(sizeof(Dnode));
        count--;
    }while(!is_malloc_ok(*DblNode) && count);
}

int is_malloc_ok(Dlink DblNode)
{
    if(DblNode == NULL)
    {
        printf("malloc error!\n");
        return 0;
    }
    return 1;
}

void create_dlink(Dlink *DblHead)
{
    Dlink DblNode;
    create_dnode(&DblNode);

    *DblHead = DblNode;
    DblNode->next = DblNode;
    DblNode->prior= DblNode;
}

void insert_dnode_head(Dlink DblHead,Dlink DblNode)
{
    DblHead->next->prior = DblNode;
    DblNode->next = DblHead->next;
    DblHead->next = DblNode;
    DblNode->prior = DblHead;
}

void display(Dlink DblHead)
{
    if(DblHead == NULL)
    {
        printf("该链表已被释放\n");
        return;
    }

    Dlink p = DblHead;
    
    printf("该链表显示是:\n");
    if(p->next == DblHead)
    {
        printf("Link is empty!\n");
    }
    else
    {
        p = p->next;
        while(p != DblHead)
        {
            printf("num is %d\n",p->num);
            p = p->next;
        }
    }
}

int length(Dlink DblHead)
{
    Dlink p = DblHead->next;
    int count = 0;

    while(p != DblHead)
    {
        count++;
        p = p->next;
    }

    return count;
}

void insert_dnode_tail(Dlink DblHead,Dlink DblNode)
{
    DblNode->prior = DblHead->prior;
    DblHead->prior->next = DblNode;
    DblNode->next = DblHead;
    DblHead->prior = DblNode;
}

void insert_dnode_mid_before(Dlink DblHead,Dlink DblNode,int num)
{
    Dlink p = DblHead->next;

    while(p != DblHead && p->num != num)
    {
        p = p->next;
    }

    if(p == DblHead)
    {
        printf("No such node!\n");
    }
    else
    {
        DblNode->prior = p->prior;
        p->prior->next = DblNode;
        DblNode->next = p;
        p->prior = DblNode;
    }
}

void insert_dnode_mid_after(Dlink DblHead,Dlink DblNode,int num)
{
    Dlink p = DblHead->next;

    while(p != DblHead && p->num != num)
    {
        p = p->next;
    }

    if(p == DblHead)
    {
        printf("No such node!\n");
    }
    else
    {
        p->next->prior = DblNode;
        DblNode->next = p->next;
        p->next = DblNode;
        DblNode->prior = p;
    }
}

void delete_dnode(Dlink DblHead,int num)
{
    Dlink p = DblHead->next;

    while(p != DblHead && p->num != num)
    {
        p = p->next;
    }

    if(p == DblHead)
    {
        printf("No such node!\n");
    }
    else
    {
        p->next->prior = p->prior;
        p->prior->next = p->next;
        free(p);
    }
}

Dlink find(Dlink DblHead,int num)
{
    Dlink p = DblHead->next;

    while(p != DblHead && p->num != num)
    {
        p = p->next;
    }

    if(p == DblHead)
    {
        p = NULL;
        return p;
    }
    else
    {
        return p;
    }
}

void make_empty(Dlink DblHead)
{
    Dlink p = DblHead->next;
    Dlink q;

    while(p != DblHead)
    {
        q = p->next;
        p->next->prior = p->prior;
        p->prior->next = p->next;
        free(p);
        p = q;
    }
}

void release_dlink(Dlink *DblHead)
{
    make_empty(*DblHead);
    free(*DblHead);
    *DblHead = NULL;
}

int main()
{
    Dlink DblHead;
    Dlink DblNode;
    int i;
    int num;

    create_dlink(&DblHead);

    for(i = 0 ;i < 5; i++)
    {
        create_dnode(&DblNode);
        DblNode->num = i + 1;

        //insert_dnode_head(DblHead,DblNode);
        insert_dnode_tail(DblHead,DblNode);
    }

    display(DblHead);
    printf("该链表长度为%d\n\n",length(DblHead));


    create_dnode(&DblNode);
    printf("请输入你想插入的结点的数值:");
    scanf("%d",&DblNode->num);
    printf("请输入你想在值为哪个的结点前插入该结点:");
    scanf("%d",&num);

    insert_dnode_mid_before(DblHead,DblNode,num);

    display(DblHead);
    printf("该链表长度为%d\n\n",length(DblHead));


    create_dnode(&DblNode);
    printf("请输入你想插入的结点的数值:");
    scanf("%d",&DblNode->num);
    printf("请输入你想在值为哪个的结点后插入该结点:");
    scanf("%d",&num);

    insert_dnode_mid_after(DblHead,DblNode,num);

    display(DblHead);
    printf("该链表长度为%d\n\n",length(DblHead));

    
    printf("请输入你想删除的结点的数值:");
    scanf("%d",&num);

    delete_dnode(DblHead,num);
    
    display(DblHead);
    printf("该链表长度为%d\n\n",length(DblHead));

    
    printf("请输入你想查找的结点的数值:");
    scanf("%d",&num);

    DblNode = find(DblHead,num);
    if(DblNode == NULL)
    {
        printf("没有这个结点\n");
    }
    else
    {
        printf("这个结点的数值是%d\n\n",DblNode->num);
    }

    make_empty(DblHead);

    display(DblHead);
    printf("该链表长度为%d\n\n",length(DblHead));

    release_dlink(&DblHead);
    display(DblHead);
    
    

    return 0;
}

小练：

要注意的点：

  1. 前指针和后指针名字
  2. MakeEmpty函数我清空的时候并没有每删一个都保持环，所以最后一步要让head的prior指向head，不然再加node就会有错
  3. Display函数要判断一下头结点是否为空！空就是已经被释放了！这个也要注意别忘了
  4. Delete函数里也要注意删除指针的时候，前后两个节点有两根线要连，不要只连一个了
#include <stdio.h>
#include <stdlib.h>

struct node
{
	int num;
	struct node *prior;
	struct node *next;
};

typedef struct node Node;
typedef struct node *Link;

int CreateNode(Link *new_node)
{
	*new_node = (Link)malloc(sizeof(Node));

	if(*new_node == NULL)
		return 0;
	return 1;
}

int CreateLink(Link *head)
{
	if(!CreateNode(head))
		return 0;

	(*head)->next = (*head);
	(*head)->prior = (*head);
	return 1;
}

void InsertHead(Link head, Link node)
{
	head->next->prior = node;
	node->next = head->next;
	head->next= node;
	node->prior = head;
}

void InsertTail(Link head, Link node)
{
	head->prior->next = node;
	node->prior = head->prior;
	head->prior = node;
	node->next = head;
}

void InsertBefore(Link head, Link node, int num)
{
	Link p = head->next;

	while(p != head)
	{
		if(p->num == num)
		{
			p->prior->next = node;
			node->prior = p->prior;
			node->next = p;
			p->prior = node;
			return;
		}
		p = p->next;
	}

	printf("Cannot find the node!\n");
}

void InsertAfter(Link head, Link node, int num)
{
	Link p = head->next;

	while(p != head)
	{
		if(p->num == num)
		{
			p->next->prior = node;
			node->next = p->next;
			p->next = node;
			node->prior = p;
			return;
		}
		p = p->next;
	}

	printf("Cannot find the node!\n");
}

void Delete(Link head, int num)
{
	Link p = head->next;

	while(p != head)
	{
		if(p->num == num)
		{
			p->prior->next = p->next;
			p->next->prior = p->prior;
			free(p);
			return;
		}
		p = p->next;
	}

	printf("Cannot find the node!\n");
}

void Display(Link head)
{
	Link p = head->next;

	if(p == head)
	{
		printf("Link is empty!\n");
		return;
	}

	while(p != head)
	{
		printf("num = %d\n", p->num);
		p = p->next;
	}
}

void MakeEmpty(Link head)
{
	Link p = head->next;

	while(p != head)
	{
		head->next = head->next->next;
		free(p);
		p = head->next;
	}

	head->prior = head;
}

void ReleaseLink(Link *head)
{
	MakeEmpty(*head);
	free(*head);
	*head = NULL;
}

int main()
{
	Link head;
	Link new_node;
	int i;

	CreateLink(&head);

	for(i = 0; i < 7; i++)
	{
		if(CreateNode(&new_node))
		{
			new_node->num = i + 1;
			InsertTail(head,new_node);
		}
	}

	Display(head);
	printf("\n");

	if(CreateNode(&new_node))
	{
		new_node->num = 23;
		InsertBefore(head,new_node,3);
	}

	Delete(head, 6);

	Display(head);
	printf("\n");

	MakeEmpty(head);

	for(i = 0; i < 7; i++)
	{
		if(CreateNode(&new_node))
		{
			new_node->num = i + 1;
			InsertTail(head,new_node);
		}
	}

	Display(head);
	printf("\n");

	ReleaseLink(&head);


	return 0;
}

 

IVever_KB
关注
专栏目录
带头结点的双向循环链表操作集 (25 分)
m0_63982781的博客
02-20 2654
本题要求实现一个带头结点的双向循环链表操作集。 函数接口定义： typedef int dataType; typedef struct _node { dataType data; struct _node *prev;//指向前驱的指针 struct _node *next;//指向后继的指针 }node; typedef node* List; List create_list();//创建一个空的循环链表，返回指向头节点的指针。 void insert(List
数据结构_带头结点的双向循环链表
weixin_43853178的博客
08-09 2541
带头结点的双向循环链表在进行操作的时候是要比单链表更方便的，比如说在尾删的时候，不需要遍历整个链表，头结点的上一个结点就是尾结点。凡是涉及到寻找尾结点的操作，都会比单链表方便很多。.........
带头结点双向循环 -- 双向链表
qq_53010164的博客
04-06 3005
一、双向链表初始化 图解：phead链表的最后一个节点要指向第一个节点，第一个节点要指向最后一个节点，而第一个节点和最后一个节点都是第一个节点，所以phead->next = phead->prev = phead; 代码： LTNode* InitList() { //带头节点，循环链表 //哨兵位头结点 LTNode* phead = (LTNode*)malloc(sizeof(LTNode)); phead->next = phead->prev = phe
带头结点的双向循环链表
kevin980123的编程世界
11-06 1695
带头结点的双向循环链表 程序代码如下： Dlist.h //Dlist.h typedef int DataType; typedef struct DListNode { struct DListNode* _pNext; struct DListNode* _pPre; DataType _data; }DListNode; // 初始化 void DListInit(D...
【数据结构】带头双向循环链表
m0_59292239的博客
11-07 1802
【数据结构】带头双向循环链表具体实现
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
最新发布
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
带头结点的双向循环链表数据结构
01-08
【带头结点的双向循环链表数据结构】 在数据结构中，双向循环链表是一种特殊类型的数据结构，它允许从两个方向遍历链表。在本案例中，我们需要使用C++和Java分别实现这种数据结构，并确保它们符合指定的要求。 在...
最详细的不带头结点的双循环链表
QQ845264718
11-29 1786
#include<iostream> /* 双向循环链表 一般来说循环双链表带头节点操作会方便一些的 不带头结点的循环双链表适合浏览图片 */ using namespace std; //设计节点 typedef struct doublelinknode { int data; struct doublelinknode* prior; struct doublelinknode* next; }Node; //初始化链表 Node* In...
【数据结构与算法】(6)：带头结点的双向循环链表
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-31 3600
带头结点的双向循环链表
数据结构——链表——带头结点的双向循环链表
weixin_44791940的博客
02-25 199
带头结点的双向循环链表 #include<stdlib.h> #include<stdio.h> #include"headList.h" /* 功能：创建一个空链表 参数：无 返回值： 失败返回NULL 成功返回头结点的地址 */ List * createLkList() { List * list = (List *)malloc(sizeof(List)); if(list == NULL) { printf("malloc fail\n");
一起学数据结构（4）——带头结点的双向循环链表
2301_76836325的博客
08-25 783
对双向循环链表的结点，虽然也是由数据域和指针域构成，但是，双向循环链表的指针域中，分别存储了上一个结点的地址和下一个结点的地址，为了后续方便表示，将存储上一个结点地址的指针命名为。后，根据上面给出的双向循环的链表结构不难发现：链表的第一个结点并不存储整型元素，只是用于链接下一个结点和最后一个结点。，虽然形式参数是一级指针，并且同样改变了形参的内容，但是最后的返回值返回了形式参数中存储的地址，只需要在外部定义一个指针用于接受函数的返回值即可。与单链表相同，双向链表中的结点需要同时存储多种类型的数据。
数据结构之带头结点的双向循环链表（含全部代码）
qq_61635026的博客
04-12 1061
数据结构之带头结点的双向循环链表
c++双向循环链表带头结点解决约瑟夫问题
05-12
双向循环链表是一种特殊的链表，它可以遍历整个链表，即尾节点的下一个结点是头结点，头结点的上一个结点是尾节点，这样形成的链表称为双向循环链表。带头结点的双向循环链表在头结点前面加入一个空结点，使得空结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值