单向环形链表 约瑟夫环-Java数据结构和算法

单向环形链表的实现

---

一、约瑟夫环介绍

       设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

我们假设	n = 5(5个人)
		k = 1（从第一个人开始）
		m = 2（数到2的退出）
过程如下：

---

二、解决约瑟夫环思路

用一个不带头结点的循环链表来处理Josephu 问题：
1. 先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时对应结点从链表中删除；
2. 然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

二、代码实现

1.创建单向环形链表

节点信息 代码如下：

class Node{
    private int no;
    private Node next;

    public Node(int no){
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

1.1 环形链表创建思路：

构建一个单向的环形链表思路
1. 先创建第一个节点, 让 first 指向该节点，并形成环形
2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可.

1.2环形链表的遍历：

遍历环形链表
1. 先让一个辅助指针(变量) temp，指向first节点
2. 然后通过一个while循环遍历 该环形链表即可 temp.next  == first 结束

代码如下：

   public void show(){
        if(first == null){
            System.out.println("链表为空...");
            return;
        }

        //不能修改first,所以用辅助指针
        Node temp = first;

        while(true){
            System.out.printf("小孩的编号%d\n" , temp.getNo());
            if(temp.getNext() == first){
                break;
            }
            temp = temp.getNext();
        }
    }

1.3 添加节点：

代码如下：

//添加的节点数
public void add(int nums){
    //nums的合法性
    if(nums < 1){
        System.out.println("添加数不正确...");
        return;
    }

    Node curNode = null;

    for(int i = 1 ; i <= nums ; i++){
        //根据编号创建节点
        Node data = new Node(i);
        if(first.getNo() == -1){//第一个节点的处理
            first = data;
            first.setNext(first);
            curNode = first;
        }else{//不是第一个节点
            curNode.setNext(data);
            data.setNext(first);
            curNode = data;
        }
    }
}

2.解决约瑟夫环

代码如下：

/*
startNo表示开始的编号
countNo表示间隔几个来退出
nums表示最初多少个人在圈中
 */
public void countBoy(int startNo , int countNo , int nums){
    if(first == null || startNo < 1 || startNo > nums){
        System.out.println("参数输入有误,请重新输入...");
        return;
    }

    ///创建辅助指针,完成出圈任务
    Node helper = first;
    //辅助指针需要指向最后一个节点
    while(helper.getNext() != first){
        helper = helper.getNext();
    }

    for(int i = 0 ; i  < startNo - 1 ; i++){
        first = first.getNext();
        helper = helper.getNext();
    }

    //循环操作,直到圈中只有一个节点
    while(true){
        if(helper == first){
            break;
        }
        //让first和helper指针同时移动countNo - 1
        for(int i = 0 ; i < countNo - 1 ; i++){
            first = first.getNext();
            helper = helper.getNext();
        }

        System.out.printf("%d号小孩出圈\n" , first.getNo());

        first = first.getNext();
        helper.setNext(first);
    }
    System.out.printf("最后留在圈中的小孩编号为%d\n" , helper.getNo());
}

---

总结

只需要注意只含有一个节点的时候也可以形成环即可

完整测试代码

package 链表;

/**
 * @author Weilei Zhang
 */
public class RingLinckedList {
    public static void main(String[] args) {
        CircleSingleLinkedList circleLincked = new CircleSingleLinkedList();

        circleLincked.add(25);
        circleLincked.show();
        circleLincked.countBoy(1 , 2 , 25);
    }
}

class CircleSingleLinkedList{
    //先创建任意第一个节点(后面需要修改)
    private Node first = new Node(-1);

    //添加的节点数
    public void add(int nums){
        //nums的合法性
        if(nums < 1){
            System.out.println("添加数不正确...");
            return;
        }

        Node curNode = null;

        for(int i = 1 ; i <= nums ; i++){
            //根据编号创建节点
            Node data = new Node(i);
            if(first.getNo() == -1){
                first = data;
                first.setNext(first);
                curNode = first;
            }else{
                curNode.setNext(data);
                data.setNext(first);
                curNode = data;
            }
        }

    }

    //遍历当前环形链表
    public void show(){
        if(first == null){
            System.out.println("链表为空...");
            return;
        }

        //不能修改first,所以用辅助指针
        Node temp = first;

        while(true){
            System.out.printf("小孩的编号%d\n" , temp.getNo());
            if(temp.getNext() == first){
                break;
            }
            temp = temp.getNext();
        }
    }
/*
startNo表示开始的编号
countNo表示间隔几个来退出
nums表示最初多少个人在圈中
 */
    public void countBoy(int startNo , int countNo , int nums){
        if(first == null || startNo < 1 || startNo > nums){
            System.out.println("参数输入有误,请重新输入...");
            return;
        }

        ///创建辅助指针,完成出圈任务
        Node helper = first;
        //辅助指针需要指向最后一个节点
        while(helper.getNext() != first){
            helper = helper.getNext();
        }

        for(int i = 0 ; i  < startNo - 1 ; i++){
            first = first.getNext();
            helper = helper.getNext();
        }

        //循环操作,直到圈中只有一个节点
        while(true){
            if(helper == first){
                break;
            }
            //让first和helper指针同时移动countNo - 1
            for(int i = 0 ; i < countNo - 1 ; i++){
                first = first.getNext();
                helper = helper.getNext();
            }

            System.out.printf("%d号小号出圈\n" , first.getNo());

            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号为%d\n" , helper.getNo());
    }
}

class Node{
    private int no;
    private Node next;

    public Node(int no){
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}