565-约瑟夫环问题(无头节点的单向循环链表)

约瑟夫环问题(无头节点的单向循环链表)

我们采用无头节点的单向循环链表解决约瑟夫环问题

假设k=1 , m=3
图中的1个数字代表着1个节点
我们采用双指针，初始化均指向第一个有效节点
因为单链表删除节点，用双指针方便
我们用p专门用来指向要删除的节点
q专门用来指向要删除的节点的前一个节点
但是现在比较尴尬的是，它没有头节点，所以一开始只能指向第一个有效节点

k=1的话，它们本身就在第一个元素上，从第一个元素开始报数，报道第3个，
现在我们要删除3这个节点，3出列。

然后p指向的是4节点，从1开始报数。

现在我们要删除6这个节点，6出列

p指向7这个节点，从1开始报数

现在我们要删除1节点，1出列

p指向2这个节点，从1开始报数

现在我们要删除5这个节点，5出列

p指向的是节点7，从1开始报数

现在我们要删除2这个节点，2出列

现在我们要删除的节点是8，8出列

p指向的是节点4，从1开始报数
现在我们要删除的节点是4,4出列

p和q相等的话，就表示就剩下1个节点了，这个节点7就是最后出列的

注意边界的考虑

如果k=1,m=1

就发生问题了。
我们希望p指向当前节点，q指向p的前一个节点。
但是没有头节点啊。
我们可以这样做！！！
我们初始化让q指向末尾节点！！！
末尾节点的next域就是指向头节点了

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;

struct Node
{
    Node(int data = 0) : data_(data), next_(nullptr) {}
    int data_;
    Node* next_;
};

//约瑟夫环问题 - 不带头节点的单项循环链表应用
void Joseph(Node* head, int k, int m)//head指向的是第一个有效节点 
{
    Node* p = head;
    Node* q = head;

    //q指向最后一个
    while (q->next_ != head)
    {
        q = q->next_;
    }

    //从第k个人开始报数的
    for (int i = 1; i < k; i++)
    {
        q = p;
        p = p->next_;
    }

    //p -> 第k个人
    for (;;)
    {
        for (int i = 1; i < m; i++)
        {
            q = p;
            p = p->next_;
        }

        //删除p指向的结点
        //q p node
        cout << p->data_ << " ";

        if (p == q)
        {
            delete p;
            break;
        }

        q->next_ = p->next_;
        delete p;
        p = q->next_;
    }
}

int main()
{
    Node* head = new Node(1);
    Node* n2 = new Node(2);
    Node* n3 = new Node(3);
    Node* n4 = new Node(4);
    Node* n5 = new Node(5);
    Node* n6 = new Node(6);
    Node* n7 = new Node(7);
    Node* n8 = new Node(8);

    head->next_ = n2;
    n2->next_ = n3;
    n3->next_ = n4;
    n4->next_ = n5;
    n5->next_ = n6;
    n6->next_ = n7;
    n7->next_ = n8;
    n8->next_ = head;

    Joseph(head, 1, 1);
}