数据结构篇——循环链表

最新推荐文章于 2023-10-22 20:24:23 发布
最新推荐文章于 2023-10-22 20:24:23 发布
阅读量302 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y805805/article/details/87858755
版权

判断单链表中是否有环：
 

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

typedef int ElemType;
typedef struct Node{
	ElemType data;
	struct Node *next;
}Node,circlelinklist;
Node *R;

void init(circlelinklist *L){
	L->data=0;
	L->next=L;
	R=L;
	Node *C;  // 循环点
	for(int i=1;i<=10;i++){
        Node *n=malloc(sizeof(Node));
        if(i==5){
        	C=n;
        }
        n->data=i;
        n->next=R->next;
        R->next=n;
        R=n;
	}
	R->next=C;
}
void show(circlelinklist *L){
    Node *p=L;
    printf("[");
    while(1){
    	p=p->next;
    	if(p==R){
    		printf("%d]\n",p->data);
    		break;
    	}else{
    		printf("%d",p->data);
    	}
    }
}
void hasloopA(circlelinklist *L){
	Node *A=L;
	Node *B=L;
	while(A->next!=B->next->next){
		A=A->next;
		B=B->next->next;
	}
	printf("有环！\n");
}
void hasloopB(circlelinklist *L){
    Node *A=L;
    Node *B=L;
    int count=0;
    while(1){
         A=A->next;
         cunt++;
         B=L;
         for(int i=0;i<count;i++){
             B=B->next;
             if(A->data==B->data&&count!=i){
                 printf("有环！%d\n",A->data);
             	 return;
             }
         }
    }
}
void main(){
	circlelinklist L;
	init(&L);
	show(&L);
	// hasloopA(&L);
	hasloopA(&L);
    hasloopB(&L);
}

约瑟夫环问题（1）

据说著名犹太历史学家Josephus有过一下的故事： 在罗马人占领乔塔帕特后，39个犹太人与Josephus及他的一个朋友躲到一个洞中，39个犹太人决定宁 愿死也不要被敌人抓到，于是决定一个自杀方式，41个人排成一个圆圈，有第1个人开始报数，每报数到第3 个人该人就必须自杀，然后由下一个人重新开始报数，直到所有人都自杀身亡为止。 然而Josephus和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16 个与第31个位置，于是逃过了这场死亡游戏。

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

typedef int ElemType;
typedef struct Node{
	ElemType data;
	struct Node *next;
}Node,circlelinklist;

void init(circlelinklist *L){
	L->next=L;
	L->data=0;
	Node *R=L;
	for(int i=1;i<=41;i++){
		Node *n=malloc(sizeof(Node));
		n->data=i;
		n->next=R->next;
		R->next=n;
		R=n;
		L->data++;
    }
	R->next=L->next;
}	
void josephus(circlelinklist *L){
	Node *p=L;
    int count=0；
    while(L->data>0){
        p=p->next;
        count++;
        if(count==2){
            Node *n=p->next;
            p->next=n->next;
            printf("%d",n->data);
            free(n);
            L->data--;
            count=0;
        }
	}
}
void main(){
	circlelinklist L;
	init(&L);
	josephus(&L);
}

约瑟夫环问题（2）

编号为1~N的N个人按顺时针方向围坐一圈，每人持有一个密码（正整数），开始人选一个正整数作为 报数上限值M，从第一个人按顺时针方向自1开始顺序报数，报道M时停止报数。报M的人出列，将他的密 码作为新的M值，从他顺时针方向上的下一个人开始从1报数，如此下去，直至所有人全部出列为止。 （10 个人 {3,6,5,4,6,3,5,8,9,4}

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

typedef int ElemType;
typedef struct Node{
	ElemType data;
	int position;
	struct Node *next;
}Node,circlelinklist;
Node *R;
void init(circlelinklist *L){
    int pass[]={3,6,5,4,6,3,5,8,9,4};
    L->data=0;
    L->next=L;
    R=L;
    for(int i=0;i<10;i++){
    	Node *n=malloc(sizeof(Node));
    	n->data=pass[i];
    	n->position=i+1;
    	n->next=R->next;
    	R->next=n;
    	R=n;
    	L->data++;
    }
    R->next=L->next;
}
void startGame(circlelinklist *L){
    Node *p=L;
    int M;
    while(L->data>0){
        M=p->next->data;
        for(int i=0;i<M-1;i++){
            p=p->next;
        }
        Node *n=p->next;
        p->next=n->next;
        M=n->data;
        printf("%d号出列\n",n->position);
        free(n);
        L->data--;
    }
}
void main(){
	circlelinklist L;
	init(&L);
	srartGame(&L);
}

约瑟夫环问题（3）

逢七过，不用解释了吧。8个人100以内

#include<stdio.h>
#incllude<stdlib.h>
#define TRUE 1
#define FALSE 0
typedef int Boolean;
typedef int ElemType;
type struct Node{
	ElemType position;
    struct Node *next;
}Node,circlelinklist;
Node *R;

void init(circlelinklist *L){
	L->data=0;
	L->next=L;
	R=L;
	for(int i=1;i<=8;i++){
		Node *n=malloc(sizeof(Node));
		n->data=i;
		n->next=R->next;
		R->next=n;
		R=n;
		L->data++;
	}
	R->next=L->next;
}
Boolean isContaionSeven(int num){
	// 12%10~2 1  712%10 2 71%10 1 
    while(num!=0){
    	if(num%10==7){
    		return TRUE;
    	}else{
    		num=num/10;
    	}
    }
    return FALSE;
}
void fengsevenguo(circlelinklist *L){
	Node *p=L;
	for(int i=1;i<=100;i++){
		p=p->next;
		if(p->data==4){ //取4号位应该说过的数字
	        if(i%7==0||isContaionSeven(i)){
            printf("%d号位:%d\n",p->data,i);
		    }
		
		}
	}
}
void main(){
	circlelinklist L;
	init(&L);
	fengsevenguo(&L);
}

数字集  人集

#include<stdio.h>
#incllude<stdlib.h>
#define TRUE 1
#define FALSE 0
typedef int Boolean;
typedef int ElemType;
typedef int position;

typedef struct LNode{ //数字集 单列表
	ElemType data;
	struct LNode *next;
}LNode,NumList;

typedef struct Person{
	ElemType data; //人的位置
	NumList list; // 人的数字集
    struct Person *next;
}Person，PersonList;

Person *R; //人的循环列表的尾指针

void insert(NumList *L,int num){
	LNode *n=malloc(sizeof(LNode));
	n->data=num;
	n->next=L->next;
	L->next=n;
	L->data++;
}

void initList(NumList *L){
    L->data=0;
    L->next=NULL;
}
void init(PersonList *p){
    p->position=0;
    p->next=p;
    R=p;
    for(int i=1;i<=8;i++){
    	Person *n=malloc(sizeof(Person));
    	n->data=i; //位置
    	initList(&(*n)n->list);
        n->next=R->next;
    	R->next=n;
    	R=n;
    	p->data++；
    }
    R->next=p->next;
}
Boolean isContaionSeven(int num){
	// 12%10~2 1  712%10 2 71%10 1 
    while(num!=0){
    	if(num%10==7){
    		return TRUE;
    	}else{
    		num=num/10;
    	}
    }
    return FALSE;
}
void fengsevenguo(PersonList *p){
	Person *p=p;
	for(int i=1;i<=100;i++){
		p=p->next;
		if(i%7==0||isContaionSeven(i)){
			insert(p->list,i);
		}
	}
}
void showList(NumList *L){
	LNode *n=L;
	for(int i=0li<L->data;i++){
        if(i=L->data-1){
        	printf("%d]\n",n->data);
        }else{
        	printf("%d",n->data);
        }
	}
}
void show(PersonList *p){
    Person *p=p;
    for(int i=0;i<p->data;i++){
    	p=p->next;
    	printf("%d号玩家：",p->data);
    	showList(p->list);
    }
}
void main(){
	PersonList p;
	init(&p);
	fengsevenguo(&p);
	show(&p);
}

魔术师发牌问题

魔术师利用一副牌中的13张黑牌，预先将他们拍好后叠放在一起，牌面朝下。对观众说：“我不看牌， 只数数就可以猜到每张牌是什么，我大声数数，你们听，不信？现场演示。”魔术师将最上面的那张牌数为 1，把他翻过来正好是黑桃A，将黑桃A放在桌子上，第二次数1,2，将第一张牌放在这些牌的下面，将第二 张牌翻过来，正好是黑桃2，也将它放在桌子上，这样依次进行将13张牌全部翻出，准确无误。那么，牌的 开始顺序如何安排的？

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1 //已经被·赋值
#define FALSE 0  //没有赋值
typedef int ElemType;
typedef int Status;
typedef struct Node{
	ElemType data;
	int flag;   //标记 在初始化时使用
	struct Node *next;
}Node,circlelinklist;
Node *R;

void init(circlelinklist *L){
	L->data=0;
	L->next=L;
	R=L;
	for(int i=1;i<=13;i++){
		Node *n=malloc(sizeof(Node));
		n->data=0;
		n->flag=FALSE;
		n->next=R->next;
		R->next=n;
		R=n;
		L->data++;
	}
	R->next=L->next;
	Node *p=L;
	// 对13张牌进行赋值
	for(int i=1;i<=L->data;i++){
		int count=0;
		while(count<i){
            p=p->next;
            if(p->flag==TRUE){
            	continue;
            }
            count++;
            if(count==i){
            	p->data=i;
            	p->flag=TRUE;

            }
		}
	}
}
void show(circlelinklist *L){
	Node *p=L;
	printf("[");
	while(1){
		p=p->next;
		if(p=R){
            printf("%d]\n",p->data);
            break;
		}else{
			printf("%d",p->data);
		}
	}
}
void play(circlelinklist *L){
	Node *p=R;
	Node *pre=R;
	int num=1; // 初来的那张牌  2 3
	int count=0;
	while(L->data>0){
		while(count<num){
			pre=p;
            p=p->next;
            count++;
            if(count==num){
                Node *n=p;
                pre->next=n->next;
                printf("%d\n",n->next);
                p=pre;
                free(n);
                L->data--;
            }
		}
		count=0;
		num++;
	}
}
void main(){
	circlelinklist L;
	init(&L);
	show(&L);
	play(&L);

}

拉丁方阵问题

拉丁方阵是一种n×n的方阵，方阵中恰有n种不同的元素，每种元素恰有n个，并且每种元素在一行一列 中恰好出现一次

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

typedef int ElemType;
type struct Node{
	ElemType data;
	struct Node *next;
}Node,circlelinklist;
Node *R;

void init(circlelinklist *L){
	L->data=0;
	L->next=L;
	for(i=1;i<=9;i++){
		Node *n=malloc(sizeof(Node));
		n->data=i;
		n->next=R->next;
		R=n;
		L->data++;
	}
	R->next=L->next;
}
void show(circlelinklist *L){
	NOde *p=R;
	for(int i=1;i<=L->data;i++){
		p=p->next; //当i=1 从第一个元素开始
		n=p;
		while(1){
			printf("%d",n->data);
			n=n->next;
			if(n==p){
				break;
			}
		}
		printf("\n");
	}
}
void main(){
	circlelinklist L;
	init(&L);
	show(&L);
}

 

 

2022冲鸭
关注
数据结构——循环链表
m0_70184760的博客
07-16 216
数据结构——循环链表——C语言实现
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3285
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
数据结构——围圈报数
tengqifa的博客
03-29 1544
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; struct Node{ int data; struct Node *next; }; int main() { struct Node *head, *s, *q, *t; head = (struct Node*)malloc(sizeof(struct Node)); q = (...
【数据结构】循环链表
debug...
08-16 433
循环链表以及解决
【C语言数据结构】循环单链表
zouli415的博客
09-19 886
CircleLinkList.h 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
单链表 循环遍历和递归遍历 以及循 环求结点个数和递归求结点个数 的思考
I_AM_KK的博客
07-30 935
我前面有很多文章一直说，递归和循环是一样的，可以相互转换。 循环是一直重复某个语句，递归是一直调用自己。要想转化，递归就得好好想想自己的内部代码和循环执行的那句代码的关系（应当一样）。 1.打印单链表 非递归 void printLnode (l* p){ while(p){ print(p); p = p->next; } } 递归 void printLnode (l* p){ print(p); printLnode (p->next); } 内容上，打印的代码不变，循
数据结构 循环链表之约瑟夫问题
y1058012795的专栏
11-29 396
 #include #include #include using namespace std;    #define ElemType string typedef struct LNode {  ElemType info;  struct LNode* next; }LNode,* Listq； //循环链表初始化 头针指Lq向最后一个数据 bool Ini
数据结构——循环链表的操作1
09-27
数据结构——循环链表的操作1 数据结构——循环链表的操作1 数据结构——循环链表的操作1 数据结构——循环链表的操作1
数据结构——循环链表的操作2
09-27
数据结构——循环链表的操作1 数据结构——循环链表的操作1 数据结构——循环链表的操作1 数据结构——循环链表的操作1
数据结构——双向循环链表（C语言实现）
最新发布
GDYJLXQ的博客
10-22 362
双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
案例 jquery ajax 搜索框
weixin_44593999的博客
09-10 319
/* 捕获用户输入行为 1. 绑定键盘事件-> keydown ，keyup, keypress 2. 绑定输入事件->input */ $('#search').bind('input',function(){ // 清除前面的 $('.alart>ul').empty() // 根据用户...
单链表及其相关操作（注释详细）
qq_63524487的博客
05-04 624
啥都不说直接上代码！ #include<iostream> using namespace std; typedef int Status; typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; //初始化 Status InitList(LinkList &L) { L=new LNode; L->next=NULL;
【Dongle】【数据结构】Linklist L、Linklist *L、Node *p 和Node p
热门推荐
郑晓东 廊坊师范学院信息技术提高班 十二期
10-10 1万+
Linklist L、Linklist *L、Node *p 和Node p的区分
循环链表
TS1130的专栏
09-14 268
#include <stdio.h> #include <string.h> #include <malloc.h> #include <stdbool.h> typedef struct DuLNode { int data; struct DuLNode *prior; struct DuLNode *next; } D...
java中的循环单链表
you_never_alone的博客
05-05 1735
先认识一下循环单链表，循环单链表就是在单链表的基础上让他首尾相接，实现逻辑上的循环。和单链表一样，先创建一下class TestClink{          //循环单链表 class Entry{ int data; Entry next; public Entry(){ data = -1; next = null; } public Entry(in...
数据结构刷题日常
qq_36987489的博客
03-18 1853
数据结构刷题日常实验一：线性表实验二：栈实验三：队列实验四：二叉树实验五：哈夫曼树实验八：排序 实验一：线性表 实验目的 （1）了解线性表的逻辑结构特性是数据元素之间存在着线性关系，在计算机中 表示这种关系有顺序存储结构和链式存储结构； （2）掌握这两种存储结构的描述方法； （3）掌握线性表的基本操作（查找、插入、删除） ； （4）考虑时间和空间复杂度设计算法。 实验内容（实验题目与说明） （1...
数据结构-----双向循环链表
qq_38345598的博客
10-13 242
瞎扯:白天被迫改一个重现都无法重现的错误.各种百度，各种测试,头发掉了一地，然鹅还是没解决出来 。所以晚上复习数据结构放松一下                                 DualCircleLinkList.h的代码(你也可以省略函数声明) typedef int status; typedef int ElemType; typedef struct Dua...
c++实现线性表中的顺序表（数据结构课程作业）
weixin_30902675的博客
09-26 331
一、题目简介 实现顺序表的创建、初始化、赋值、插入、删除、按数据查找元素位置、按元素位置查找数据、清空、删除 的操作，以上操作用可用菜单选项完成 二、源程序代码 #include<iostream> #define MAXSIZE 100 using namespace std; typedef int ElemType; typedef...
循环链表的操作详解
lixin_com的博客
09-13 4605
一、概述 循环链表：循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 从上图看出循环链表有两个成员：data 和 next 由此可创建循环链表和它的一些基本操作如下： 注明：它的操作其实与单链的操作差不多，只要注意判断标志即可。 #pragma once //循环链表,尾节点的next指向头 typedef struct C
使用循环链表解决约瑟夫问题——数据结构解析
"该资源主要讨论如何使用循环链表解决约瑟夫问题，并涉及了多种数据结构的概念，包括单链表、链表的游标类、静态链表、循环链表、多项式相加、双向链表以及稀疏矩阵。其中，约瑟夫问题是一个经典的算法问题，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值