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

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

还需改进：

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

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

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

//没写查找函数

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

struct node 
{
    int num;

    struct node * next;
};

typedef struct node Node;
typedef struct node * Link;

void create_node(Link *new_node)
{
    int count = 10;

    do
    {
        *new_node = (Link)malloc(sizeof(Node));
        count--;
    }while(!is_malloc_ok(*new_node) && count);
}

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

void create_link(Link *head)
{
    Link new_node;

    create_node(&new_node);
    *head = new_node;
    new_node->next = new_node;
}

void insert_node_head(Link head,Link new_node)
{
    new_node->next = head->next;
    head->next = new_node;
}

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

    Link p = head->next;

    printf("\n该环形链表为:\n");

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

int length(Link head)
{
    Link p = head->next;
    int count = 0;

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

void insert_node_tail(Link head,Link new_node)
{
    Link p = head;

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

    new_node->next = p->next;
    p->next = new_node;
}

void insert_node_mid_before(Link head,Link new_node,int num)
{
    Link p = head;

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

    if(p->next == head)
    {
        printf("No such node!\n");
        return;
    }
    else
    {
        new_node->next = p->next;
        p->next = new_node;
    }
}

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

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

    if(p == head)
    {
        printf("No such node!\n");
        return;
    }
    else
    {
        new_node->next = p->next;
        p->next = new_node;
    }
}

void delete_node(Link head,int num)
{
    Link p = head;
    Link q;

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

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

void make_empty(Link head)    //其他函数和带头结点的单链表的函数一样（只是把NULL改成head?)
{                             //但这个清空稍有区别，删时它还是成环的
    Link p = head;
    Link q;

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

void release_link(Link *head)
{
    make_empty(*head);
    free(*head);
    *head = NULL;
}

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

    create_link(&head);

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

        //insert_node_head(head,new_node);
        insert_node_tail(head,new_node);
    }

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


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

    insert_node_mid_before(head,new_node,num);
    
    display(head);
    printf("该环形链表长度为%d\n\n",length(head));


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

    insert_node_mid_after(head,new_node,num);
    
    display(head);
    printf("该环形链表长度为%d\n\n",length(head));


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

    delete_node(head,num);
    display(head);
    printf("该环形链表长度为%d\n\n",length(head));


    make_empty(head);

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

    release_link(&head);
    if(head == NULL)
    {
        printf("双链表已释放\n");
    }

    return 0;
}

小练：

需要注意的点： 

  1. 有好多函数
  2. 空链的时候，头结点的下一个还是头结点自己
  3. 在结点前，后插入，我的代码思路和老师有点点不一样，还是按自己的顺一点
#include <stdio.h>
#include <stdlib.h>

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

typedef struct node Node;
typedef Node * Link;

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

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

int CreateLink(Link *head)
{
	if(!CreateNode(head))
		return 0;
	(*head)->next = (*head);
}

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 InsertHeadNode(Link head, Link node)
{
	node->next = head->next;
	head->next = node;
}

void InsertTailNode(Link head,Link node)
{
	Link p = head;

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

	node->next = p->next;
	p->next = node;
}

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

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

	printf("No such node!\n");
	return;
}

void InsertBeforeNode(Link head, Link node, int num)
{
	Link p = head;

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

	printf("No such node!\n");
	return;
}

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

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

	printf("No such node!\n");
	return;
}

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

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

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


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

	CreateLink(&head);

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

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

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

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

	if(CreateNode(&new_node))
	{
		new_node->num = 56;
		InsertAfterNode(head,new_node, 1);
	}

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

	DeleteNode(head,7);

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

	MakeEmpty(head);

	Display(head);

	ReleaseLink(&head);

	return 0;
}

 

IVever_KB
关注
专栏目录
最详细的不带头结点的双循环链表
QQ845264718
11-29 1781
#include<iostream> /* 双向循环链表 一般来说循环双链表带头节点操作会方便一些的 不带头结点的循环双链表适合浏览图片 */ using namespace std; //设计节点 typedef struct doublelinknode { int data; struct doublelinknode* prior; struct doublelinknode* next; }Node; //初始化链表 Node* In...
单循环链表（带头结点和不带头结点）
05-21
自己在实验课是做的。主要是单循环链表，有带头结点和不带头结点两种情况。 文件里分别进行了实现。有两个文件
带头节点循环单链表【详细解析+完整代码】
ChenLin55的博客
05-17 5665
循环单链表在单链表的基础上进行改进。思考一下，普通单链表从表头遍历到表尾，时间复杂度为o(n)，如果我想从表尾找到表头呢？时间复杂度也还是o(n)。怎么快速从表尾找到表头，于是引入了循环链表。整个链表形成闭环，表尾找到表头，时间复杂度为o(1)。循环单链表是首尾相连的一种单链表，即将最后一个结点的空指针改为指向头结点或第一个结点的形成一个环型，最后一个结点称为尾指针:tail。判断单链表为空的条件是 head->next == NULL，而判断循环单链表为空的条件是。
带头节点的循环链表
swty3356667的博客
02-02 5050
带头节点的循环链表，循环链表的尾节点指向头节点 头文件clist.h #pragma once //带头节点的循环链表 //循环链表的尾节点指向头节点 typedef struct CNode { int data;//数据域 struct CNode *next;//指向下一个节点的地址 }CNode,*CList; void InitList(CList plist); /
数据结构+算法连载八 单向环形链表和约瑟夫问题(Josephu)
cyberHerman的博客
11-12 913
先来看看单向环形链表，顾名思义就是 单向链表，构成环状，结尾的节点的next域指向头结点。 其实这个和约瑟夫问题很类似，约瑟夫就是个环形链表，然后出圈的问题。 Josephu 问题为： 设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止...
【数据结构】- (带头结点)循环双向链表 - 详细实现思路及代码
wkd_007的博客
04-22 1508
这里使用带有头结点的循环双向链表进行讲解，从初始化双向链表、插入数据、删除数据、查找数据、销毁双向链表5个操作进行说明，需要注意的是，循环双向链表的插入、删除操作需要改变两个指针域；其他操作基本和单链表一致。
带头结点的双向循环链表
07-17
本项目以C++语言实现了带头结点的双向循环链表，这将有助于我们深入理解这一概念。 首先，双向循环链表与单链表的主要区别在于每个节点不仅包含数据，还包含两个指针：一个指向前一个节点，另一个指向后一个节点。...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
带头结点双链循环线性表.rar_循环双链表
09-14
在“带头结点双链循环线性表”中，“头结点”是一个特殊的结点，它的存在主要是为了方便对链表进行操作，例如插入和删除元素。头结点不存储实际的数据，而是作为链表的起点，连接着链表中的第一个元素。同时，由于是...
单循环链表之带头结点
会飞的蜗牛
08-09 1205
初始化void listInit(LinkList &L) { L=new node; L->next=L; } 头插法void CrateLink_H(LinkList &L) { LinkList p; int n,m; cout<<"please input a number:"; cin>>n; for(int i=0;i<n;i++
带头结点和不带头结点的循环链表
11-24
这学期学数据结构，写了带头结点和不带头结点的循环链表，供其他在校学生参考学习，体会在链表中带头结点和不带头结点的差别
带头结点循环链表
AIDOU_LBJ的博客
09-20 1969
上一个说的是单链表，其实循环链表跟单链表类似，单链表最后一个节点(p)的next域为NULL即p->next=NULL而循环链表(plist)的则为头结点的地址，即p->next=plist。其余的基本操作和单链表几乎一样，仅仅是单链表循环结束条件为!=NULL，而循环链表是!=plist。 基本操作为：初始化，插入（头插、尾插），查找，删除，判空，求长，摧毁，逆置。 .cpp: #incl
Java实现带头结点的循环双链表
yunshangguafan的博客
06-04 312
最近又回顾了一下数据结构链表的实现，就随便写了一个带头结点的循环双链表的实现，如果有不当的地方，希望大家多多指教。 话不多说，代码走起 1. 准备gong
数据结构四：线性表之带头结点的单向循环链表的设计
最新发布
weixin_47040031的博客
04-25 1673
单向循环链表的插入，删除算法与单链表基本一致，所不同的是若操作在链表的尾部进行，则判断条件发生变化不同，以让单链表继续保持循环的性质。因此，需要记住循环链表判空和判断是否为尾巴结点的条件！即循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p->next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。
数据结构中实现带头的循环单链表
weixin_44007988的博客
08-26 236
数据结构中实现带头的循环单链表 需要实现的方法 package cn.dataStructure2.com; public interface HeadLinked { //头插法 void addFirst(Object data); //尾插法 void addLast(Object data); //任意位置插入,第一个数据节点为0号下标 ...
循环链表的头节点（java）
lianggege88的博客
05-22 1599
问题描述： 寻找循环链表的头结点。 思路分析： 寻找头节点，就要记录以前找过的结点，故我们使用hash表来记录结点，如果遇到重复，则直接返回即可。 代码见下： 结点类定义 package List; class Node{ int data; Node next; public Node(int data) { this.data = data; } } 实现类定义： package List; import java.util.HashSet; p
no such file or directory, open '/node_modules/.staging/
热门推荐
YooHoeh的博客
08-26 1万+
报错 在使用npm过程中连续产生多行报错 no such file or directory, open '/node_modules/.staging/ 原因 npm版本配置不一致导致 解决方案 npm cache clean -f npm install -g npm npm stable...
运行node项目时报错：/usr/bin/env: node: No such file or directory
努力奋斗
04-27 7594
ln -s /usr/bin/nodejs /usr/bin/node
c++双向循环链表带头结点解决约瑟夫问题
05-12
解决约瑟夫问题的方法有多种，其中一种常用方法是使用双向循环链表带头结点。 双向循环链表是一种特殊的链表，它可以遍历整个链表，即尾节点的下一个结点是头结点，头结点的上一个结点是尾节点，这样形成的链表称为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值