5.单向链表的经典问题（C语言详解：约瑟夫环，拉丁方阵，魔术师发牌问题，判断链表是否有环）

2023-11-03 18:10
文章标签 语言 问题 链表 详解 判断 是否 经典 有环 约瑟夫 方阵 单向 拉丁 发牌 魔术师

本文主要是介绍5.单向链表的经典问题（C语言详解：约瑟夫环，拉丁方阵，魔术师发牌问题，判断链表是否有环），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

1.约瑟夫问题

      1.1经典的约瑟夫问题

      1.2更加复杂的约瑟夫问题

      1.3 用一维数组求解约瑟夫问题

2.拉丁方阵问题

3.判断单链表是否含有环

       3.1  比较步数法

       3.2  快慢指针法

4. 魔术师发牌问题

5.几个经典问题的编程实现

       5.1 C语言实现循环链表

       5.2 测试结果

6. 参考资料

1.约瑟夫问题

约瑟夫问题跟当下流行的吃鸡游戏非常类似，本身就是一个生存游戏，与吃鸡游戏不同的是，这个游戏靠的不是钢枪或者当伏地魔，而是用数学规则来决定生死！

      1.1经典的约瑟夫问题

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

问题：用循环链表模拟约瑟夫问题，把41个人自杀的顺序编号输出。

解决方法：下图是核心程序，完整程序可以参考第4部分，有比较详细的注解。

typedef int ElemType;
typedef struct Node
{ElemType data;struct Node *Next;
}Node;typedef Node* linklist;//给节点指针取别名
typedef enum Bool
{FALSE,TRUE//枚举默认值从0开始，依次加1
}Bool;
void CreateListEnd(linklist* L,int n);//尾插法创建链表
void Josephus(linklist* L);//经典的约瑟夫问题void CreateListEnd(linklist* L,int n)//新建循环链表
{linklist p,rear;int i;(*L)=(linklist)malloc(sizeof(Node));if((*L)==NULL){printf("结点申请失败，初始化未完成！\n");exit(0);}(*L)->data=1;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklist)malloc(sizeof(Node));p->data=i+1;//rand()%100+1;p->Next=*L;//新节点是新的尾节点，它指向头结点rear->Next=p;rear=rear->Next;}
}void Josephus(linklist* L)//约瑟夫环
{linklist p;//指向待删结点的前面linklist q;int i=0;for(p=(*L)->Next;p->Next!=p;p=p->Next->Next)/*假设每次报数m个死一个人，则* 1.起始p从头向后移动m-2次；* 2.后续循环中，p每次向后移动m-1次。
* */{q=p->Next;p->Next=q->Next;printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++i);free(q);}printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);free(p);
}

      1.2更加复杂的约瑟夫问题

编号为1～N的N个人按顺时针方向围坐一圈，每人持有一个密码（正整数，可以自由输入），开始人选一个正整数作为报数上限值M，从第一个人按顺时针方向自1开始顺序报数，报道M时停止报数。报M的人出列，将他的密码作为新的M值，从他顺时针方向上的下一个人开始从1报数，如此下去，直至所有人全部出列为止。

问题：模拟这个问题的自杀编号。

基本思路：用含有两个数据域的循环链表来实现，第一个数据域data存放游戏者的编号，第二个数据域code存放此人的密码，程序设计与经典的约瑟夫问题基本相同。基本数据结构为：

typedef struct NodeCode
{int data;//玩家编号int code;//密码struct Node *Next;
}NodeCode;   //带密码的约瑟夫环的结点
typedef NodeCode* linklistcode;//给节点指针取别名

核心程序为：  

void CreateListEndCode(linklistcode* L,int n);//尾插法创建带密码的约瑟夫环
void printListCode(linklistcode L);//遍历约瑟夫环
void JosephusCode(linklistcode* L,int M);//更加复杂的约瑟夫问题void CreateListEndCode(linklistcode* L,int n)//尾插法创建带密码的约瑟夫环
{linklistcode p,rear;int i;(*L)=(linklistcode)malloc(sizeof(NodeCode));if((*L)==NULL){printf("结点申请失败，初始化未完成！\n");exit(0);}(*L)->data=1;//(*L)->code=rand()%100+1;//3;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklistcode)malloc(sizeof(NodeCode));p->data=i+1;//p->code=rand()%100+1;//3;//p->Next=*L;//新节点是新的尾节点，它指向头结点rear->Next=p;rear=rear->Next;//}
}void printListCode(linklistcode L)
{linklistcode p=L;if(L==NULL){printf("当前循环链表是空链表  \n\n\n");return;}printf("\n玩家编号%3d",p->data);//第一个结点的元素值for(p=p->Next;p!=L;p=p->Next)printf("%4d",p->data);printf("\n玩家密码%3d",L->code);//第一个结点的元素值for(p=L->Next;p!=L;p=p->Next)printf("%4d",p->code);printf("\n\n");
}void JosephusCode(linklistcode* L,int M)
{/*假设每次报数m个死一个人，则
* 1.起始p从头向后移动m-2次；
* 2.后续循环中，p每次向后移动m-1次。
*/linklistcode p=*L,q;//指向待删结点的前面int i,num;for(i=0;i<M-2;i++)p=p->Next;num=0;while(p->Next!=p){q=p->Next;p->Next=q->Next;printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++num);M=q->code;free(q);for(i=0;i<M-1;i++)p=p->Next;}printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);free(p);
}

      1.3 用一维数组求解约瑟夫问题

博主学习了魔术师发牌问题后，就想到了用一维数组模仿单链表，同时用标志位来标注每次被淘汰的人（0表示没有被淘汰，1表示已经被淘汰了）。下面是这种方法的源程序代码，n表示参加的总人数，数组cord存储的玩家的状态，下标+1表示玩家的编号，例如cord[i]如果为0就表示第i+1位（数组下标从0开始）玩家目前还活着；用取余运算来模拟循环链表结构：number=(number+1)%n；通过不断查找来确定每次被淘汰的玩家的编号，一旦第i+1位被淘汰，则cord[i]=1。下面是完整的源程序，其中n表示玩家总人数，m表示每次报多少个数，对于约瑟夫问题来说，n=41，m=3。

int Josephus(int n, int m)
{int* cord=(int*)malloc(n*sizeof(int));//类似于魔术师发牌问题：数组中0表示还在游戏中int count=0,number=-1;                 //淘汰的总人数for(int i=0;i<n;i++)cord[i]=0;while(count<n-1){for(int j=0;j<m;){number=(number+1)%n;if(cord[number]==0)j++;}cord[number]=1;//printf("%d  ",number);count++;}for(count=0;count<n;count++)if (cord[count]==0)return count;return -1;
}

 

2.拉丁方阵问题

拉丁方阵是大家熟知的数独的起源，规则比数独稍微简单一些。

问题描述：

拉丁方阵（英语：Latin square）是一种 n × n 的方阵，在这种 n × n 的方阵里，恰有 n 种不同的元素，每一种不同的元素在同一行或同一列里只出现一次。

当一个拉丁方阵的第一行与第一列的元素按顺序排列时，此为这个拉丁方阵的标准型，英语称为"reduced Latin square, normalized Latin square, 或Latin square in standard form"。因为标准型拉丁方阵非常简单，所以下面就实现标准型。

思路分析：

标准型拉丁方阵的基本特点是，第一行按1,2,3...n的顺序排列；第二行就是将第一行循环右移一位，即2,3,4，.....,n,1；以此类推，后续每一行的数据都是他的前一行数据循环右移一位形成的。标准型拉丁方阵的这种特点很适合用循环链表来实现：

void Latin(int n);
void Latin(int n)
{linklist list,head,p;//head每次后移一位，表示拉丁方阵每一行的新起点位置int i;CreateListEnd(&list,n);//创建单链表head=list;for(i=0;i<n;i++){p=head;printf("\n%d  ",p->data);//第一个结点的元素值for(p=p->Next;p!=head;p=p->Next)printf("%d  ",p->data);head=head->Next;}printf("\n\n");
}

3.判断单链表是否含有环

单链表中含有环的定义是，链表的尾节点指向了链表的某个结点，而不是指向空。例如下面的单链表就含有环： 

解决这个问题主要有两种方法：比较步数法，和快慢指针法。

       3.1  比较步数法

开始的时候有两个指针p和q，他们都指向链表第一个结点，p每次往后遍历一个结点，而q每次都从链表的第一个结点开始，p每往后遍历一次就比较二者相遇（二者指向同一个结点）各时自遍历的步数，当步数不同的时候，说明有环。核心程序如下：

Bool haveCirc1(linklist L)
{linklist p,q;int p_step,q_step,i=0;for(p=L,p_step=1;p!=NULL;p=p->Next,p_step++){for(q=L,q_step=1;q!=NULL;q=q->Next,q_step++){i++;if(p==q){if(q_step!=p_step){printf("该链表含有环，循环结点位置为：%d    循环语句执行%d次\n",q_step,i);return TRUE;}elsebreak;}}}printf("当前链表无环， 循环语句共执行了%d次\n",i);return FALSE;
}

       3.2  快慢指针法

刚开始的时候快慢指针都指向链表第一个结点，每次快指针向前走两步，而慢指针每次只往前走一步，当二者在运动的过程中发生相遇时，说明存在环。

Bool haveCirc2(linklist L)
{linklist fast,slow;int i;slow=fast=L;for(i=1;(fast->Next!=NULL)&&(fast->Next->Next!=NULL);){fast=fast->Next->Next;//fast的结点数依次为：3/5/7/9...if(fast==slow||fast->Next==slow)//fast的结点数依次为：3/5/7/9...，而slow为1/2/3/4...，无环时二者不可能相遇，fast更不可能出现在slow后面{printf("该链表含有环，循环语句执行%d次\n\n",i);return TRUE;}slow=slow->Next;//分别为1/2/3...i++;}printf("当前链表无环， 循环语句共执行了%d次\n\n",i-1);return FALSE;
}

4. 魔术师发牌问题

问题描述

一位魔术师掏出一叠扑克牌，魔术师取出其中13张黑桃，洗好后，把牌面朝下。说：“我不看牌，只数一数就能知道每张牌是什么？”魔术师口中念一，将第一张牌翻过来看正好是A；魔术师将黑桃A放到桌上，继续数手里的余牌，第二次数1，2，将第一张牌放到这叠牌的下面，将第二张牌翻开，正好是黑桃2，也把它放在桌子上。第三次数1，2，3，前面二张牌放到这叠牌的下面，取出第三张牌，正好是黑桃3，这样依次将13张牌翻出，全部都准确无误。

求解：魔术师手中牌的原始顺序是什么样子的？

基本思路

假设手中有13张牌，当牌没有翻开的时候可以给他标记为0，当牌翻开后标记为实际的数字。这样一来问题就变得简单了，可以使用循环链表来实现：首先创建一个长度为13的循环链表，链表中所有元素都是0，表示13张牌都是未知状态，然后给第一个元素标记上实际数字1，这时候第一张牌非0，只要是非0就表示这个位置的牌放在了桌子上，要从剩下的元素为0的12个结点中再数2个，给第2个标记上数字2；依次类推。。。

程序中需要注意的是，每次计数的时候只计数不在桌子上的牌，即链表中元素为0的结点。

核心程序如下：

void InitCards(linklist* L,int n);//尾插法创建全0链表
void MagicianDealingCards(linklist* L,int n);//确定每张牌的位置
void displayCards(linklist L);//将所有牌按顺序显示
void InitCards(linklist* L,int n)
{linklist p,rear;int i;(*L)=(linklist)malloc(sizeof(Node));(*L)->data=0;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklist)malloc(sizeof(Node));p->data=0;//rand()%100+1;p->Next=*L;//新节点是新的尾节点，它指向头结点rear->Next=p;rear=rear->Next;}
}void MagicianDealingCards(linklist* L,int n)
{linklist p=*L;int num,i;//每次发牌前计数的个数为num个p->data=1;for(num=2;num<=n;num++){for(i=0;i<num;){p=p->Next;if(p->data==0)//这个位置的牌已经放在桌子上了i++;}p->data=num;}
}void displayCards(linklist L)
{linklist p=L;char card[13]={'A','2','3','4','5','6','7','8','9','10','J','Q','K'};printf("黑桃%c  ",card[L->data-1]);//第一张肯定是Afor(p=p->Next;p!=L;p=p->Next)printf("黑桃%c  ",card[p->data-1]);printf("\n\n");
}

5.几个经典问题的编程实现

       5.1 C语言实现循环链表

（1）循环链表的声明 cirlinklist.h

#ifndef CIRLINKLIST_H
#define CIRLINKLIST_Htypedef int ElemType;
typedef struct Node
{ElemType data;struct Node *Next;
}Node;typedef Node* linklist;//给节点指针取别名
typedef enum Bool
{FALSE,TRUE//枚举默认值从0开始，依次加1
}Bool;typedef struct NodeCode
{int data;//玩家编号int code;//密码struct Node *Next;
}NodeCode;   //带密码的约瑟夫环的结点
typedef NodeCode* linklistcode;//给约瑟夫环的指针取别名void CreateListEnd(linklist* L,int n);//尾插法创建链表
void traverseList(linklist L);//遍历链表//1.约瑟夫环
void Josephus(linklist* L);//经典的约瑟夫问题
void CreateListEndCode(linklistcode* L,int n);//尾插法创建带密码的约瑟夫环
void printListCode(linklistcode L);//遍历约瑟夫环
void JosephusCode(linklistcode* L,int M);//更加复杂的约瑟夫问题//2.拉丁方阵
void Latin(int n);//3.判断链表是否有环
#if 0
判断是否有环的2种方法:
1.两个指针，p每次继续往后遍历一个结点，而q每次从头开始，记录二者相遇时（同一个结点，即结点的地址相同）各自遍历的步数，当步数不同的时候，说明有环；
2.用快慢指针的方法：快慢指针相遇的时候说明有环
#endif
void CreateSingleListEnd(linklist* L,int n);//尾插法创建单链表
void displaySingleList(linklist L);//显示单链表
void CreateCirListEnd(linklist* L,int n);//尾插法创建带环链表
void displayCirList(linklist L,int n);//显示循环链表，只循环显示n个元素即可
Bool haveCirc1(linklist L);//方法一：比较步数法
Bool haveCirc2(linklist L);//方法二：快慢指针法//4.魔术师发牌问题
/*0表示这张牌还没有翻开*/
void InitCards(linklist* L,int n);//尾插法创建全0链表
void MagicianDealingCards(linklist* L,int n);//确定每张牌的位置
void displayCards(linklist L);//将所有牌按顺序显示
#endif // CIRLINKLIST_H

（2） 循环链表的实现 cirlinklist.c

#include "cirlinklist.h"
#include <stdio.h>void traverseList(linklist L)
{linklist p=L;if(L==NULL){printf("当前循环链表是空链表  \n\n\n");return;}elseprintf("%d  ",p->data);//第一个结点的元素值for(p=p->Next;p!=L;p=p->Next){printf("%d  ",p->data);//        p=p->Next;}printf("\n\n");
}void CreateListEnd(linklist* L,int n)
{linklist p,rear;int i;(*L)=(linklist)malloc(sizeof(Node));if((*L)==NULL){printf("结点申请失败，初始化未完成！\n");exit(0);}(*L)->data=1;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklist)malloc(sizeof(Node));p->data=i+1;//rand()%100+1;p->Next=*L;//新节点是新的尾节点，它指向头结点rear->Next=p;rear=rear->Next;}
}void Josephus(linklist* L)
{linklist p;//指向待删结点的前面linklist q;int i=0;for(p=(*L)->Next;p->Next!=p;p=p->Next->Next)/*假设每次报数m个死一个人，则* 1.起始p从头向后移动m-2次；* 2.后续循环中，p每次向后移动m-1次。
* */{q=p->Next;p->Next=q->Next;printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++i);free(q);}printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);free(p);
}void CreateListEndCode(linklistcode* L,int n)//尾插法创建带密码的约瑟夫环
{linklistcode p,rear;int i;(*L)=(linklistcode)malloc(sizeof(NodeCode));if((*L)==NULL){printf("结点申请失败，初始化未完成！\n");exit(0);}(*L)->data=1;//(*L)->code=rand()%100+1;//3;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklistcode)malloc(sizeof(NodeCode));p->data=i+1;//p->code=rand()%100+1;//3;//p->Next=*L;//新节点是新的尾节点，它指向头结点rear->Next=p;rear=rear->Next;//}
}void printListCode(linklistcode L)
{linklistcode p=L;if(L==NULL){printf("当前循环链表是空链表  \n\n\n");return;}printf("\n玩家编号%3d",p->data);//第一个结点的元素值for(p=p->Next;p!=L;p=p->Next)printf("%4d",p->data);printf("\n玩家密码%3d",L->code);//第一个结点的元素值for(p=L->Next;p!=L;p=p->Next)printf("%4d",p->code);printf("\n\n");
}void JosephusCode(linklistcode* L,int M)
{/*假设每次报数m个死一个人，则
* 1.起始p从头向后移动m-2次；
* 2.后续循环中，p每次向后移动m-1次。
*/linklistcode p=*L,q;//指向待删结点的前面int i,num;for(i=0;i<M-2;i++)p=p->Next;num=0;while(p->Next!=p){q=p->Next;p->Next=q->Next;printf("%d号玩家被淘汰了！      目前已经淘汰%d个人\n",q->data,++num);M=q->code;free(q);for(i=0;i<M-1;i++)p=p->Next;}printf("%d号玩家成功吃鸡了!   他是唯一幸存者！！\n\n\n",p->data);free(p);
}void Latin(int n)
{linklist list,head,p;//head每次后移一位，表示拉丁方阵每一行的新起点位置int i;CreateListEnd(&list,n);//创建单链表head=list;for(i=0;i<n;i++){p=head;printf("\n%d  ",p->data);//第一个结点的元素值for(p=p->Next;p!=head;p=p->Next)printf("%d  ",p->data);head=head->Next;}printf("\n\n");
}void CreateSingleListEnd(linklist* L,int n)
{linklist p,end;int i;*L=(linklist)malloc(sizeof(Node));(*L)->data=1;end=*L;for(i=1;i<n;i++){p=(linklist)malloc(sizeof(Node));p->data=i+1;//rand()%100+1;p->Next=NULL;end->Next=p;end=p;}
}void displaySingleList(linklist L)
{linklist p=L;while(p){printf("%d  ",p->data);p=p->Next;}printf("\n");
}void CreateCirListEnd(linklist* L,int n)
{linklist p,rear;int i;(*L)=(linklist)malloc(sizeof(Node));(*L)->data=1;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklist)malloc(sizeof(Node));p->data=i+1;//rand()%100+1;rear->Next=p;rear=rear->Next;//}rear->Next=(*L)->Next->Next->Next;//循环到第4个结点
}void displayCirList(linklist L,int n)
{linklist p=L;int i;if(L==NULL){printf("当前循环链表是空链表  \n\n\n");return;}printf("%d  ",p->data);//第一个结点的元素值for(i=1;i<n;i++){p=p->Next;printf("%d  ",p->data);}printf("\n");
}Bool haveCirc1(linklist L)
{linklist p,q;int p_step,q_step,i=0;for(p=L,p_step=1;p!=NULL;p=p->Next,p_step++){for(q=L,q_step=1;q!=NULL;q=q->Next,q_step++){i++;if(p==q){if(q_step!=p_step){printf("该链表含有环，循环结点位置为：%d    循环语句执行%d次\n",q_step,i);return TRUE;}elsebreak;}}}printf("当前链表无环， 循环语句共执行了%d次\n",i);return FALSE;
}Bool haveCirc2(linklist L)
{linklist fast,slow;int i;slow=fast=L;for(i=1;(fast->Next!=NULL)&&(fast->Next->Next!=NULL);){fast=fast->Next->Next;//fast的结点数依次为：3/5/7/9...if(fast==slow||fast->Next==slow)//fast的结点数依次为：3/5/7/9...，而slow为1/2/3/4...，无环时二者不可能相遇，fast更不可能出现在slow后面{printf("该链表含有环，循环语句执行%d次\n\n",i);return TRUE;}slow=slow->Next;//分别为1/2/3...i++;}printf("当前链表无环， 循环语句共执行了%d次\n\n",i-1);return FALSE;
}void InitCards(linklist* L,int n)
{linklist p,rear;int i;(*L)=(linklist)malloc(sizeof(Node));(*L)->data=0;//(*L)->Next=*L;//第一个结点rear=*L;for(i=1;i<n;i++){p=(linklist)malloc(sizeof(Node));p->data=0;//rand()%100+1;p->Next=*L;//新节点是新的尾节点，它指向头结点rear->Next=p;rear=rear->Next;}
}void MagicianDealingCards(linklist* L,int n)
{linklist p=*L;int num,i;//每次发牌前计数的个数为num个p->data=1;for(num=2;num<=n;num++){for(i=0;i<num;){p=p->Next;if(p->data==0)//这个位置的牌已经放在桌子上了i++;}p->data=num;}
}void displayCards(linklist L)
{linklist p=L;char card[13]={'A','2','3','4','5','6','7','8','9','10','J','Q','K'};printf("黑桃%c  ",card[L->data-1]);//第一张肯定是Afor(p=p->Next;p!=L;p=p->Next)printf("黑桃%c  ",card[p->data-1]);printf("\n\n");
}

（3）测试程序 main.c

#include <stdio.h>
#include "cirlinklist.h"int main()
{linklist list;int num;linklistcode listcode;printf("\n\n             11.约瑟夫环\n");CreateListEnd(&list,41);printf("原链表\n");traverseList(list);Josephus(&list);printf("\n\n             12.带密码的约瑟夫环\n");CreateListEndCode(&listcode,50);printf("原链表\n");printListCode(listcode);JosephusCode(&listcode,3);printf("\n\n             13.拉丁方阵\n");printf("请输入拉丁方阵的阶数：");scanf("%d",&num);Latin(num);printf("\n\n             14.判断链表是否含有环\n");linklist singlist,circlist;printf("\n测试单链表");CreateSingleListEnd(&singlist,10);displaySingleList(singlist);printf("方法一：逐个遍历法\n");haveCirc1(singlist);printf("\n方法二：快慢指针法\n");haveCirc2(singlist);printf("\n测试带环的链表");CreateCirListEnd(&circlist,10);displayCirList(circlist,10+2);//多显示两个，可以看到循环点的位置printf("方法一：逐个遍历法\n");haveCirc1(circlist);printf("\n方法二：快慢指针法\n");haveCirc2(circlist);printf("\n\n             15.魔术师发牌问题\n");linklist cards;InitCards(&cards,13);MagicianDealingCards(&cards,13);displayCards(cards);return 0;
}

       5.2 测试结果

（1）经典的约瑟夫环

（2）更加复杂的约瑟夫环

(3）拉丁方阵

(4) 判断单链表是否有环

(5)魔术师发牌问题

 

6. 参考资料

[1]小甲鱼的教学视频：https://www.bilibili.com/video/av2975983/?p=18

[2]百度百科，拉丁方阵：https://baike.baidu.com/item/%E6%8B%89%E4%B8%81%E6%96%B9%E9%98%B5/4413910

[3]百度经验，魔术师发牌问题：https://jingyan.baidu.com/article/0aa223755363c688cc0d6485.html

[4]单链表是否有环的基本思路：https://www.bilibili.com/video/av2975983/?p=19

这篇关于5.单向链表的经典问题（C语言详解：约瑟夫环，拉丁方阵，魔术师发牌问题，判断链表是否有环）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/339951。

相关文章

linux生产者，消费者问题

linux生产者，消费者问题

pthread_cond_wait() ：用于阻塞当前线程，等待别的线程使用pthread_cond_signal()或pthread_cond_broadcast来唤醒它。 pthread_cond_wait() 必须与pthread_mutex 配套使用。pthread_cond_wait()函数一进入wait状态就会自动release mutex。当其他线程通过pthread
阅读更多...
C语言中联合体union的使用

C语言中联合体union的使用

本文编辑整理自： http://bbs.chinaunix.net/forum.php?mod=viewthread&tid=179471 一、前言 “联合体”(union）与“结构体”(struct)有一些相似之处。但两者有本质上的不同。在结构体中,各成员有各自的内存空间, 一个结构变量的总长度是各成员长度之和。而在“联合”中,各成员共享一段内存空间, 一个联合变量
阅读更多...
问题：第一次世界大战的起止时间是 #其他#学习方法#微信

问题：第一次世界大战的起止时间是 #其他#学习方法#微信

问题：第一次世界大战的起止时间是 A.1913 ~1918 年 B.1913 ~1918 年 C.1914 ~1918 年 D.1914 ~1919 年 参考答案如图所示
阅读更多...
2024.6.24 IDEA中文乱码问题（服务器 控制台 TOMcat）实测已解决

2024.6.24 IDEA中文乱码问题（服务器 控制台 TOMcat）实测已解决

1.问题产生原因： 1.文件编码不一致：如果文件的编码方式与IDEA设置的编码方式不一致，就会产生乱码。确保文件和IDEA使用相同的编码，通常是UTF-8。2.IDEA设置问题：检查IDEA的全局编码设置和项目编码设置是否正确。3.终端或控制台编码问题：如果你在终端或控制台看到乱码，可能是终端的编码设置问题。确保终端使用的是支持你的文件的编码方式。 2.解决方案： 1.File -> S
阅读更多...
Java面试八股之怎么通过Java程序判断JVM是32位还是64位

Java面试八股之怎么通过Java程序判断JVM是32位还是64位

怎么通过Java程序判断JVM是32位还是64位 可以通过Java程序内部检查系统属性来判断当前运行的JVM是32位还是64位。以下是一个简单的方法： public class JvmBitCheck {public static void main(String[] args) {String arch = System.getProperty("os.arch");String dataM
阅读更多...
vcpkg安装opencv中的特殊问题记录（无法找到opencv_corexd.dll）

vcpkg安装opencv中的特殊问题记录（无法找到opencv_corexd.dll）

我是按照网上的vcpkg安装opencv方法进行的（比如这篇：从0开始在visual studio上安装opencv（超详细，针对小白）），但是中间出现了一些别人没有遇到的问题，虽然原因没有找到，但是本人给出一些暂时的解决办法： 问题1： 我在安装库命令行使用的是 .\vcpkg.exe install opencv 我的电脑是x64，vcpkg在这条命令后默认下载的也是opencv2:x6
阅读更多...
十四、观察者模式与访问者模式详解

十四、观察者模式与访问者模式详解

21.观察者模式 21.1.课程目标 1、 掌握观察者模式和访问者模式的应用场景。 2、 掌握观察者模式在具体业务场景中的应用。 3、 了解访问者模式的双分派。 4、 观察者模式和访问者模式的优、缺点。 21.2.内容定位 1、 有 Swing开发经验的人群更容易理解观察者模式。 2、 访问者模式被称为最复杂的设计模式。 21.3.观察者模式 观 察 者 模 式 ( Obser
阅读更多...
大语言模型（LLMs）能够进行推理和规划吗？

大语言模型（LLMs）能够进行推理和规划吗？

大语言模型（LLMs），基本上是经过强化训练的 n-gram 模型，它们在网络规模的语言语料库（实际上，可以说是我们文明的知识库）上进行了训练，展现出了一种超乎预期的语言行为，引发了我们的广泛关注。从训练和操作的角度来看，LLMs 可以被认为是一种巨大的、非真实的记忆库，相当于为我们所有人提供了一个外部的系统 1（见图 1）。然而，它们表面上的多功能性让许多研究者好奇，这些模型是否也能在通常需要系
阅读更多...
【操作系统】信号Signal超详解|捕捉函数

【操作系统】信号Signal超详解|捕捉函数

🔥博客主页： 我要成为C++领域大神🎥系列专栏：【C++核心编程】 【计算机网络】 【Linux编程】 【操作系统】 ❤️感谢大家点赞👍收藏⭐评论✍️ 本博客致力于知识分享，与更多的人进行学习交流 ​ 如何触发信号 信号是Linux下的经典技术，一般操作系统利用信号杀死违规进程，典型进程干预手段，信号除了杀死进程外也可以挂起进程 kill -l 查看系统支持的信号
阅读更多...
问题-windows-VPN不正确关闭导致网页打不开

问题-windows-VPN不正确关闭导致网页打不开

为什么会发生这类事情呢？ 主要原因是关机之前vpn没有关掉导致的。 至于为什么没关掉vpn会导致网页打不开，我猜测是因为vpn建立的链接没被更改。 正确关掉vpn的时候，会把ip链接断掉，如果你不正确关掉，ip链接没有断掉，此时你vpn又是没启动的，没有域名解析，所以就打不开网站。 你可以在打不开网页的时候，把vpn打开，你会发现网络又可以登录了。 方法一 注意：方法一虽然方便，但是可能会有
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2