数据结构与算法之单向环形链表

单向环形链表

josephu问题

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

提示

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

2号出列，1号的next指向3号

4号出列，3号的next指向5号

1号出列，5号的next指向3号

5号出列，3号的next指向自己

构建环形链表

思路:

• 先创建第一个节点，让first指向该节点
• 当我们每创建一个新的节点，就把该节点加入到已有的环形链表中即可。

遍历环形链表

1. 先让一个辅助指针(curBoy)，指向first节点
2. 然后通过while循环遍历环形链表即可 curBoy.next == first 结束
3. 代码实现

package linkedlist;

public class josephu {
    public static void main(String[] args) {
        // 测试一把
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();
    }
}

// 创建一个环形的单向链表
class CircleSingleLinkedList {
    // 创建一个first节点，当前没有编号
    private Boy first = new Boy(-1);
    // 添加小孩节点，构建成一个环形链表
    // 传入要加入多少个小孩
    public void addBoy(int nums){
        // nums 做一个数据校验
        if (nums<1) {
            System.out.println("nums的值不正确");
            return;
        }
        // 使用for来创建我们的环形链表
        // 从一号开始加到 nums
        Boy curBoy = null; //辅助指针，帮助构建环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i); // 将编号为 i 的小孩创建出来
            // 如果是第一个小孩
            if (i == 1) {
                first = boy; // first指向第一个小孩
                first.setNext(first); // 构成一个环 自己指向自己
                curBoy = first; //让这个辅助节点指向第一个小孩
            } else {
                curBoy.setNext(boy); // 上一个bog指向下一个boy
                boy.setNext(first); // 下一个boy指向first
                curBoy = boy; // curBoy指向下一个节点
            }
        }
    }

    // 遍历当前的环形链表
    public void showBoy() {
        //判断链表是否为空
        if (first == null) {
            System.out.println("没有人和小孩~~");
            return;
        }
        // 因为first不能动,因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号 %d \n",curBoy.getNo());
            if (curBoy.getNext()==first) {
                // 已经遍历完毕
                break;
            }
            curBoy = curBoy.getNext(); // curBoy 后移
        }
    }

}

// 创建一个Boy类，表示一个节点
class Boy {
    private int no; // 编号
    private Boy next; //指向下一个节点，默认null
    public Boy(int no) {
        this.no = no;
    }

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

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

    public int getNo() {
        return no;
    }

    public Boy getNext() {
        return next;
    }
}

这里我详细讲一下环形链表构造代码的实现原理
4. 原理图
首先我们创建一个空的first(私有对象)和一个空的辅助节点

当我们创建第一个boy的时候,通过

first = boy; // first指向第一个小孩

注意: 我们传递的都是类的地址，千万不要以为是单纯的赋值

first.setNext(first);

这里设置的boy1的next指回自己

curBoy = first; //让这个辅助节点指向第一个小孩

当我们创建第二个boy时

curBoy.setNext(boy);

简单点说，就是利用curBoy这个辅助节点(携带着的是boy1的地址，可以认为是boy1)的next指向boy2

boy.setNext(first);

这个就是让boy2的next指向first

curBoy = boy; // curBoy指向下一个节点

以此类推

解决josephu问题

思路:

• 需求创建一个辅助指针(变量)helper,事先应该指向环形链表的最后这个节点
  补充: 小孩报数前，先让first和helper移动k-1次 (先让first先来到k小孩子上)
• 当小孩报数的时候，让first和helper指针同时移动m-1次(简单点说就是helper永远跟在first的后面) 这时就可以将first指向的小孩节点出圈
  first = first.next
  helper.next = first
• 原来first指向的节点就没有任何引用了，就会被回收

代码实现

// 根据用户的输入，计算出小孩出圈的顺序
/**
 * @param startNo  表示从第几个小孩开始数数
 * @param countNum 表示数记下
 * @param nums     表示最初有多少小孩在圈中
 */
public void countBoy(int startNo, int countNum, int nums) {
    // 先对数据进行校验
    if (first == null || startNo < 1 || startNo > nums) {
        System.out.println("参数输入有误，请重新输入");
        return;
    }
    // 创建一个辅助指针，帮助完成小孩出圈
    Boy helper = first;
    // helper实现指向最后的这个节点
    while (true) {
        if (helper.getNext() == first) {
            break;
        }
        helper = helper.getNext();
    }
    // 小孩报数前，先让first和helper移动k-1次
    for (int j=0; j< startNo -1;j++) {
        first = first.getNext();
        helper = helper.getNext();
    }
    // 当小孩报数的时候，让first和helper指针同时移动m-1次,然后出圈
    while (true) {
        if (helper == first) {
            // 说明圈中只有一个人
            break;
        }
        // first和helper指针同时移动countNum-1次
        for (int j = 0;j<countNum-1;j++){
            first = first.getNext();
            helper = helper.getNext();
        }
        // 这时first指向的节点就是出圈的小孩节点
        System.out.printf("小孩%d出圈\n",first.getNo());
        // 这时first指向的小孩节点出圈
        first = first.getNext();
        // helper指向first的下一个节点
        helper.setNext(first);
    }
    System.out.printf("最后留在圈中的小孩编号%d \n",first.getNo());
}

我们来看图分析代码
我们取 5个小孩 第1个人开始报数 数2下就出一个小孩的例子
首先得到我们的环形链

得到我们的helper

// helper实现指向最后的这个节点
    while (true) {
        if (helper.getNext() == first) {
            break;
        }
        helper = helper.getNext();
    }

开始数，数到boy2 停下，此时boy2要出圈，此时first指到的小孩出圈

让first移动到下一位

// 这时first指向的小孩节点出圈
first = first.getNext();

// helper指向boy2的下一个节点
helper.setNext(first);

注意: 此时first已经指向了boy3了，于是我们就利用Java的垃圾回收机制把boy2给剔除了

再来重复一遍，从boy3开始数，数到boy5的时候停下

first指向下一位，helper指向first

到最后helper跟first相同的时候，证明圈中只有一个人
大功告成！！

特别感谢 韩顺平 老师的教导

教学视频地址
https://www.bilibili.com/video/av54029771?p=29