Java数据结构—环形链表

构建一个单向的环形链表

思路

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

遍历环形链表

思路

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

代码实现

遍历当前的环形链表

  public  void showBoy(){
        //判断链表是否为空
        if(first == null){
            System.out.println("没有任何节点");
            return;
        }
        //使用辅助指针
        Boy curBoy = first;
        while (true){
            System.out.printf("小孩的编号%d \n",curBoy.getNo());
            if (curBoy.getNext() == first){
                break;
            }
            curBoy = curBoy.getNext();
        }
    }

创建一个环形的单向链表

 //创建一个first节点
            private Boy first = new Boy(-1);
            //添加节点，构建环形链表
            public void addBoy(int nums){
                //nums 做数据校验
                if(nums < 1){
                    System.out.println("nums的值不正确");
                    return;
                }
                Boy curBOy = null;//辅助指针，帮助构建环形链表
                for(int i = 1;i<=nums;i++){
                    //根据编号创建
                    Boy boy = new Boy(i);
                    //如果是第一个小孩
                    if(i == 1){
                        first = boy;
                        first.setNext(first);//构成环
                        curBOy = first;//指向第一个
                    }else {
                        curBOy.setNext(boy);
                        boy.setNext(first);
                        curBOy = boy;
                    }
                }
            }

创建一个辅助指针(变量) helper , 最开始要让helper应该指向环形链表的最后这个节点，位于first的后面

 while (true) {
        if (helper.getNext() == first) { // 说明helper指向最后小孩节点
            break;
        }
        helper = helper.getNext();
    }

小孩报数前，先让 first 和 helper 移动 k - 1次，让first指向最开始报数的编号位置，helper指向first后方一个

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

这里是一个循环操作，直到圈中只有一个节点时退出循环

 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.setNext(first); //
    }
    System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());

完整代码

package DataStructure.linkedList;

/**
 * @author 周润发
 * @date 2021/9/21 15:58
 */

public class Joseful {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);// 加入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;
                }
                Boy curBOy = null;//辅助指针，帮助构建环形链表
                for(int i = 1;i<=nums;i++){
                    //根据编号创建
                    Boy boy = new Boy(i);
                    //如果是第一个小孩
                    if(i == 1){
                        first = boy;
                        first.setNext(first);//构成环
                        curBOy = first;//指向第一个
                    }else {
                        curBOy.setNext(boy);
                        boy.setNext(first);
                        curBOy = boy;
                    }
                }
            }
            //遍历当前的环形链表
            public  void showBoy(){
                //判断链表是否为空
                if(first == null){
                    System.out.println("没有任何节点");
                    return;
                }
                //使用辅助指针
                Boy curBoy = first;
                while (true){
                    System.out.printf("小孩的编号%d \n",curBoy.getNo());
                    if (curBoy.getNext() == first){
                        break;
                    }
                    curBoy = curBoy.getNext();
                }
            }
            // 根据用户的输入，计算出小孩出圈的顺序
            /**
             *
             * @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) { // 说明helper指向最后小孩节点
                        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.setNext(first); //
                }
                System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());

            }
        }

        // 创建一个Boy类，表示一个节点
        class Boy {
            private int no;// 编号
            private Boy next; // 指向下一个节点,默认null

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

            public int getNo() {
                return no;
            }

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

            public Boy getNext() {
                return next;
            }

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

    }