C++循环链表实现约瑟夫问题（类模板）

最新推荐文章于 2024-08-28 15:47:43 发布
最新推荐文章于 2024-08-28 15:47:43 发布
阅读量817 收藏 12
点赞数
文章标签： 链表 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80937868/article/details/138036683
版权

目录

前言：

一、创建结点

二、创建循环链表

1.类模板定义

2.尾插函数

3.删除结点

4.清除链表

5.打印链表

三、约瑟夫问题

1.创建对应人数的循环链表

2.通过双指针和双循环实现

3.main函数

四、完整代码

前言：

        本文以类模板创建循环链表的方式解决约瑟夫问题，并非为最简方法，倾向于加强对类模板以及链表的学习及使用，全文仅供参考，如有不足的地方还望多多指教。

提示：以下是本篇文章正文内容，代码注释较为详细，可供参考

一、创建结点

        创建类模板Node，结点是构成链表的基本单位，注意用要用成员函数访问其私有成员，不能直接访问。

class Node {
private:
    T m_data;//数据域
    Node* m_next = nullptr;//指针域
public:

    Node(const T& val) {
        this->m_data = val;
    }//有参构造函数

    const T& data()const {
        return this->m_data;
    }//const类型访问私有成员m_data

    T& data() {
        return this->m_data;
    }//访问私有成员m_data

    Node*& next() {
        return this->m_next;
    }//访问私有成员m_next
};

二、创建循环链表

1.类模板定义

template<class T>
class SList {
private:
    Node<T>* m_head = nullptr, * m_tail = nullptr;//定义头指针和尾指针
    int m_length = 0;//链表长度
public:
    SList() = default;//使用默认构造函数
    ~SList() { clear(); };//析构函数
    void clear();//清除链表
    void push_back(const T& val);//尾插函数
    void erase(const T& val);//删除结点
    void game();//约瑟夫问题
    void show();//打印链表(序号）
};

2.尾插函数

        通过将尾指针指针域指向头指针来实现循环。

template<class T>
void SList<T>::push_back(const T& val) {
    Node<T>* node = new Node<T>(val);//
    if (this->m_head == nullptr) {
        this->m_head = this->m_tail = node;
        this->m_tail->next() = this->m_head;//尾指针指向头指针，实现循环
    }//当链表为空的时候
    else {
        this->m_tail->next() = node;
        this->m_tail = node;
        this->m_tail->next() = this->m_head;
    }//链表不为空的时候
    this->m_length++;//插入后链表长度+1
}

3.删除结点

        删除时要特别注意当删除对象是头结点和尾结点时头指针和尾指针的处理，一定要先将这两个指针指向改变再进行删除，否则在后面的操作中可能出现丢失链表以及野指针的问题。

template<class T>
void SList<T>::erase(const T& val) {
    Node<T>* p = this->m_head, * q = p;
    while (p != nullptr && p->data() != val) {
        q = p;
        p = p->next();
    }//遍历链表
    if (p) {
        q->next() = p->next();
    }
    if (p == this->m_tail) {
        this->m_tail = q;
    }
    if (p == this->m_head && p) {
        this->m_head = p->next();
        this->m_tail->next() = this->m_head;
    }//当删除的结点为头节点时要先将头指针和尾指针指向下一个结点，否则可能出现野指针
    delete p;
    this->m_length--;//删除后链表长度-1
}

4.清除链表

        清除时将尾指针指针域置空，这样便可以按照单向链表的清除方式进行逐个删除，删除完后记得将尾指针置空。

template<class T>
void SList<T>::clear() {
    if (this->m_length == 0)
    {
        return;
    }//若链表为空则返回
    this->m_tail->next() = nullptr;//先将尾指针指针域置空，然后按照普通链表来进行逐个清除
    Node<T>* p = nullptr;
    while (this->m_head != nullptr) {
        p = this->m_head;
        this->m_head = this->m_head->next();
        delete p;
    }
    this->m_tail = nullptr;//将尾指针置空，避免出现野指针
}

5.打印链表

        用来输出剩余人数的序号（数据域）。

template<class T>
void SList<T>::show() {
    Node<T>* p = this->m_head;
    int first = this->m_head->data();
    for (int i = 1; i <= this->m_length; i++) {
        cout << p->data() << " ";
        p = p->next();
    }
}//遍历打印

三、约瑟夫问题

1.创建对应人数的循环链表

        展示的是成员函数game的部分代码，通过for循环插入对应人数的结点，并将这些结点的数据域赋值对应的序号（1，2，3......n）。

template<class T>
void SList<T>::game() {
    int pnum = 0, count = 0;
    cout << "游戏人数为:" << endl << "报数为:" << endl;
    cin >> pnum >> count;
    for (int i = 1; i <= pnum; i++) {
        push_back(i);
    }//向循环链表插入相同人数的结点
    cout << endl;

2.通过双指针和双循环实现

        通过两个指针，其中countinueloc是用来记录被删除人的下一个结点地址，所以它从计数时就从第二个结点开始向前推进。而location指针则是每轮中用来确定该轮被删除人的位置，它总是从countinueloc指针的位置开始报数，随其一起向前推进，直到报数值然后被删除。在下一次轮次开始时又创建一个新的location指针重复上述操作，唯有countinueloc是每一次轮次都在持续推进循环。

        第一个for循环是用来确定执行的轮次，直到剩下2个人，第二个for循环则是两个指针向前推进的位次，由报数值决定。

 Node<T>* countinueloc = this->m_head;//设置一个指针用来记录被删除人的下一个位置，方便继续计数删除
    for (int i = pnum; i > 2; i--) {     //第一个for循环用来判断需要进行多少轮
        Node<T>* location = countinueloc;//这个指针是用来执行每一轮删除任务的，每一轮斗从continueloc的位置开始进行计数
        for (int i = 0; i < count; i++) {
            location = countinueloc;
            countinueloc = countinueloc->next();
        }//第二个for用来报数，通过报数的值来决定指针前进多少个结点
        erase(location->data());//删除location指针所指的结点
        cout << "进行一轮后剩余的人序号:";
        show();
        cout << endl;
    }
    cout << "剩下获奖的2人序号是:";
    show();
}

3.main函数

int main()
{
    SList<int> game;
    game.game();
}

四、完整代码

        以下是完整代码展示，由于个人水平有限，如有错误/不严谨的地方敬请指正。

#include <iostream>
using namespace std;
template<class T>
class Node {
private:
    T m_data;//数据域
    Node* m_next = nullptr;//指针域
public:

    Node(const T& val) {
        this->m_data = val;
    }//有参构造函数

    const T& data()const {
        return this->m_data;
    }//const类型访问私有成员m_data

    T& data() {
        return this->m_data;
    }//访问私有成员m_data

    Node*& next() {
        return this->m_next;
    }//访问私有成员m_next
};

template<class T>
class SList {
private:
    Node<T>* m_head = nullptr, * m_tail = nullptr;//定义头指针和尾指针
    int m_length = 0;//链表长度
public:
    SList() = default;//使用默认构造函数
    ~SList() { clear(); };//析构函数
    void clear();//清除链表
    void push_back(const T& val);//尾插函数
    void erase(const T& val);//删除结点
    void game();//约瑟夫问题
    void show();//打印链表(序号）
};


template<class T>
void SList<T>::push_back(const T& val) {
    Node<T>* node = new Node<T>(val);//
    if (this->m_head == nullptr) {
        this->m_head = this->m_tail = node;
        this->m_tail->next() = this->m_head;//尾指针指向头指针，实现循环
    }//当链表为空的时候
    else {
        this->m_tail->next() = node;
        this->m_tail = node;
        this->m_tail->next() = this->m_head;
    }//链表不为空的时候
    this->m_length++;//插入后链表长度+1
}

template<class T>
void SList<T>::erase(const T& val) {
    Node<T>* p = this->m_head, * q = p;
    while (p != nullptr && p->data() != val) {
        q = p;
        p = p->next();
    }//遍历链表
    if (p) {
        q->next() = p->next();
    }
    if (p == this->m_tail) {
        this->m_tail = q;
    }
    if (p == this->m_head && p) {
        this->m_head = p->next();
        this->m_tail->next() = this->m_head;
    }//当删除的结点为头节点时要先将头指针和尾指针指向下一个结点，否则可能出现野指针
    delete p;
    this->m_length--;//删除后链表长度-1
}

template<class T>
void SList<T>::clear() {
    if (this->m_length == 0)
    {
        return;
    }//若链表为空则返回
    this->m_tail->next() = nullptr;//先将尾指针指针域置空，然后按照普通链表来进行逐个清除
    Node<T>* p = nullptr;
    while (this->m_head != nullptr) {
        p = this->m_head;
        this->m_head = this->m_head->next();
        delete p;
    }
    this->m_tail = nullptr;//将尾指针置空，避免出现野指针
}

template<class T>
void SList<T>::show() {
    Node<T>* p = this->m_head;
    int first = this->m_head->data();
    for (int i = 1; i <= this->m_length; i++) {
        cout << p->data() << " ";
        p = p->next();
    }
}//遍历打印

template<class T>
void SList<T>::game() {
    int pnum = 0, count = 0;
    cout << "游戏人数为:" << endl << "报数为:" << endl;
    cin >> pnum >> count;
    for (int i = 1; i <= pnum; i++) {
        push_back(i);
    }//向循环链表插入相同人数的结点
    cout << endl;

    Node<T>* countinueloc = this->m_head;//设置一个指针用来记录被删除人的下一个位置，方便继续计数删除
    for (int i = pnum; i > 2; i--) {     //第一个for循环用来判断需要进行多少轮
        Node<T>* location = countinueloc;//这个指针是用来执行每一轮删除任务的，每一轮斗从continueloc的位置开始进行计数
        for (int i = 0; i < count; i++) {
            location = countinueloc;
            countinueloc = countinueloc->next();
        }//第二个for用来报数，通过报数的值来决定指针前进多少个结点
        erase(location->data());//删除location指针所指的结点
        cout << "进行一轮后剩余的人序号:";
        show();
        cout << endl;
    }
    cout << "剩下获奖的2人序号是:";
    show();
}

int main()
{
    SList<int> game;
    game.game();
}

         

idokira
关注
约瑟夫问题（C++面向对象顺序表实现）
dream_three的博客
05-10 3050
数据结构（用面向对象方法与C++语言描述）（第二版） 殷人昆 主编
约瑟夫问题（C++面向对象--单循环链表实现）
dream_three的博客
05-31 1555
注 本代码只实现了单循环链表的部分操作 参考教材：数据结构（面向对象方法与 C++ 语言描述）（第二版） //约瑟夫问题（C++面向对象--单循环链表实现） #include&lt;iostream&gt; #include&lt;cstdlib&gt; using namespace std; template&lt;class T&gt; struct CircleLinkNode...
c++链表，解决约瑟夫环问题
05-11
自己写的链表，并用链表解决了约瑟夫环问题，大家给个意见，主要是链表
【C/C++】约瑟夫环问题
最新发布
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 814
n个人（0,1,2,3,4…n-1），围成一圈，从编号为k的人开始报数，报数报到m的人出队（报数是1,2,…下次从出队的人之后开始重新报数，循环往复，当队伍中只剩最后一个人的时候，那个人就是大王。现在，给定n，k，m，输入一行包含三个整数n,k,m。
C++循环链表实现约瑟夫问题
weixin_45723904的博客
03-30 1323
#include<iostream> #include<stdio.h> #include<string.h> #include<stdlib.h> #include <iomanip> #include<iostream> using namespace std; struct ListNode { int val; ListNode *next; ListNode() : val(0), next(nullp
C++ 用循环链表解决约瑟夫环问题
difei7767的博客
05-26 965
约瑟夫环问题 已知 n 个人(n>=1)围坐一圆桌周围，从 1 开始顺序编号，从序号为 1 的人开始报数，顺时针数到 m 的那个人出列。下一个人又从 1 开始报数，数到m 的那个人又出列。依此规则重复下去，直到所有人全部出列。请问最后一个出列的人的初始编号。 要求 输入人数 n，所报数 m，输出最后一个人的初始编号。 解决思路 首先因为是圆...
循环链表解决约瑟夫环问题（C++）
qq_58126670的博客
07-14 1937
主体思路：创建一个循环链表，每个节点储存的数据表示他们的位置，每出去一个就删除一个节点，并且将链表大小减一，当链表只剩一个节点时，终止循环 注意的点： 1.因为删除要找上一个节点，所以是m-1 2.因为在本题中只需要输出对应元素就好了，所以不需要更改尾指针，没有必要 #include<bits/stdc++.h> using namespace std; class node { public: node* next; int data; node(int a) { data = a
约瑟夫问题(丢手绢问题)
weixin_43906560的博客
08-11 382
问题复述:据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-...
数据结构循环链表解决约瑟夫问题（C++实现
12-06
一个旅行社要从n个旅客中选出一名旅客，为他提供免费的环球旅行服务。旅行社安排这些旅客围成一个圆圈，从帽子中取出一张纸条，用上面写的正整数m(<n)作为报数值。游戏进行时，从第s个人开始按顺时针方向自1开始顺序报数，报到m时停止报数，报m的人被淘汰出列，然后从他顺时针方向上的下一个人开始重新报数，如此下去，直到圆圈中只剩下一个人，这个最后的幸存者就是游戏的胜利者，将得到免费旅行的奖励。其中数据结构采用单循环链表。
[C & C++]利用循环链表解决约瑟夫环问题
自觉 觉他
01-31 3579
约瑟夫环 /C /C++ /循环链表
约瑟夫(Joseph)问题（链表）C++
allen565的博客
10-05 1066
约瑟夫(Joseph)问题的一种描述是：编号为 1，2，…,n 的 n 个人按顺时针方向围坐一圈， 每人持有一个密码（正整数），一开始任选一个整数作为报数上限 m,从第一人开始按顺时针方 向从自 1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从 他的顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止，设计 一个程序求出出列顺序。 # include<iostream> using namespace std; typ.
约瑟夫环的链表实现（C++）
03-11
约瑟夫环的链表实现（C++） 采用链表方式解决问题，代码简单，书写格式规范，有相应注释以及测试小模块。
约瑟夫问题c++
01-18
约瑟夫问题的详细且明了的c++的约瑟夫环的程序实现，分为四个部分。
循环链表实现约瑟夫环问题
11-06
循环链表实现约瑟夫环问题 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
利用循环链表实现约瑟夫环（C++语言实现）
执的博客
12-13 1387
问题背景： 来源于一个故事，后被改编为程序表示。 题目如下 博主为逆输出，若想得到正输出，只需改动很小的一部分就行，博主就不在这一一赘述了。 上代码！ #include <iostream> #include <stack> using namespace std; typedef struct Node{ int data; struct Node* next; }*pointer; int main() { int m,n; ..
利用双向循环链表实现约瑟夫环问题(C++版)
马马也的个人博客
12-21 2506
1.问题简述    约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后结果+1即为原问题的解。 2.实现思路 (1)建立一个孩子类(相当于数据结构中的...
约瑟夫环问题的循环链表实现与C++编程
总结来说，这篇实验报告通过约瑟夫环问题展示了如何在C++中使用单循环链表来模拟动态过程，强化了学生对数据结构的理解，提升了他们的编程技巧和问题解决能力。同时，它还涉及了异常处理和调试方法，为实际开发提供...
C++实现约瑟夫循环问题详解
该问题的C++实现通常涉及到数据结构的选择（如队列、链表等），循环、条件判断以及输入输出等基本编程元素。在解决约瑟夫问题时，可以采用递归或迭代的方法，每种方法都有其特点和适用场景。 递归方法是将问题分解...
北邮数据结构实验：循环链表解决约瑟夫问题
实验的目标是让学生通过C++编程，掌握基本的编程技巧，如指针、模板类和异常处理的运用，以及线性表的操作。实验内容特别强调了使用循环链表来解决这个问题。 约瑟夫问题是一个著名的理论问题，描述了一群人围坐一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值