一、单链表

1.1 单链表基本介绍

1.2 分析与实现带head头结点的单向链表

1.2.1第一种方式：尾部添加元素示意图

1.2.2 尾部添加元素的代码实现以及遍历链表的实现

1.2.3 第二种方式：根据排名将节点插入到指定位置的示意图

1.2.4 根据排名将节点插入到指定位置代码实现

1.2.5 单链表节点的修改（编号不变，名字和昵称可以改变）

1.2.6 单链表的某个节点删除图示

1.2.7 单链表的某个节点删除代码实现

1.3 代码汇总

1.4 单向链表新浪面试题:查找单链表中倒数第K个结点

1.5 腾讯面试题：单链表的反转（有点难度，但不是很大）

1.5.1 反转的思路

1.5.2 代码实现

1.6 从尾到头打印链表

1.6.1 思路分析

1.6.2 代码实现

二、双向链表

2.1 双向链表增删改查分析图解

2.2 双向链表增删改查代码实现

三、单向环形链表与约瑟夫问题

3.1 约瑟夫问题思路分析

3.2 约瑟夫问题的代码实现

一、单链表

1.1 单链表基本介绍

我们看下面的图示

如下图

链表是以节点的方法来存储，是链式存储
每个节点包含data域（存放数据），next域（指向下一个节点）
链表各个节点不一定是连续存储的
链表分带头节点的链表（头结点不存放数据）和不带头结点的链表，根据实际需求来确定

下图是带头节点的链表，其中每一个白色的矩形就是一个节点

1.2 分析与实现带head头结点的单向链表

案例：实现水浒传英雄排行榜管理

1.2.1第一种方式：尾部添加元素示意图

1.2.2 尾部添加元素的代码实现以及遍历链表的实现

public class SingleLinkedListTest {
    public static void main(String[] args) {
//      创建节点
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");


//      创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
//      加入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
//      显示
        singleLinkedList.list();
    }
}
//定义一个链表管理我们的英雄
class SingleLinkedList{
//  初始化一个头节点，头节点一般不要动
    private  HeroNode head =  new HeroNode(0,"","");

//   添加节点到单向链表
//   思路：不考虑编号的顺序时，找到当前链表的最后一个节点next指向新节点
    public void add(HeroNode heroNode){
//      因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;

//      遍历链表，找到最后，当next域是null，说明就是最后一个节点了
        while (true){
            if(temp.next ==null){
//               此时temp指向的节点已经是最后一个节点了,我们可以在这个节点后面再添加一个节点
                 temp.next = heroNode;
                 break;
            }
//           如果没有找到最后一个节点，temp就往后移动
            temp=temp.next;
        }
    }

//  遍历链表
    public void list(){
//     先判断链表是否是空
        if(head.next ==null){
            System.out.println("链表空");
            return;
        }
//      不是空，所以头结点后面会有数据
//      因为头结点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(true){
//           判断是否是空
            if(temp ==null){
                break;
            }
//          已经重写toString方法了
            System.out.println(temp);
//          输出完之后移动
            temp = temp.next;
        }
    }


}


//每个HeroNode对象就是一个结点
class HeroNode{
    public int no;            //编号（data域的一部分）
    public String name;       //名字（data域的一部分）
    public String nickname;   //昵称（data域的一部分）
    public HeroNode next; //下一个节点（next域）

//  给data域赋值
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

//  为了观察方便，我们重写toString

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

1.2.3 第二种方式：根据排名将节点插入到指定位置的示意图

  因为是单链表，我们要找到添加位置的前一个节点

1.2.4 根据排名将节点插入到指定位置代码实现

如果同一个排名添加一次后有添加了一次，我们在第二次时提醒操作失败


//   第二种方式：在添加英雄时，根据排名将英雄插入到指定位置
    public void addByOrder(HeroNode heroNode){
//      头节点不能动，我们仍然需要一个辅助指针来帮助找到添加的位置
//      因为是单链表，我们要找到添加位置的前一个节点
        HeroNode temp = head;

        while (true){
            if(temp.next ==null){
//               说明temp已经是链表的最后了
//               此时我们只能把结点添加到最后
                temp.next=heroNode;
                break;
            }
            if(temp.next.no>heroNode.no){
//               说明我们的节点的位置应该放到temp节点与temp.next节点之间
                heroNode.next = temp.next;
                temp.next = heroNode;

                break;
            }else if(temp.next.no ==heroNode.no){
//               说明节点已经存在了，不能添加了
                System.out.println("准备添加的英雄编号"+heroNode.no+"已经存在，不能再添加");
                break;
            }
//           指针移动
            temp = temp.next;
        }


    }

public class SingleLinkedListTest {
    public static void main(String[] args) {
//      创建节点
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");


//      创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
//      加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
//      显示
        singleLinkedList.list();
    }
}

1.2.5 单链表节点的修改（编号不变，名字和昵称可以改变）

//    修改，根据编号来修改，编号不可修改
    public void update(HeroNode newHeroNode){
//        判断是否是空
        if(head.next ==null){
            System.out.println("链表为空");
            return;
        }
//      定义辅助变量
        HeroNode temp = head.next;
        while (true){
            if(temp == null){
//              这种情况是最后一个节点的下一个位置，到最后一个位置的下一个位置.遍历结束了
//              这种情况其实是没找到
                System.out.println("此节点的编号并不存在，并不能修改");
                break;
            }
            if(temp.no == newHeroNode.no){
//               找到了
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
                break;
            }
            temp = temp.next;
        }

    }

public class SingleLinkedListTest {
    public static void main(String[] args) {
//      创建节点
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");


//      创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
//      加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
//      显示
        singleLinkedList.list();
        singleLinkedList.update(new HeroNode(1,"账账","好人卡"));
        System.out.println("************************");
        singleLinkedList.list();
    }
}

1.2.6 单链表的某个节点删除图示

1.2.7 单链表的某个节点删除代码实现

//  删除节点
    public void del(int no){
//        判断是否是空
        if(head.next ==null){
            System.out.println("链表为空");
            return;
        }
//      如果no编号存在的话，temp最终会指向被删除节点no的前一个位置
        HeroNode temp = head;
        while (true){
            if(temp.next == null){
//               说明temp后面已经没有了
                System.out.println("链表中不存在"+no+"编号的人员");
               break;
            }
            if(temp.next.no == no){
//               说明我们temp节点后面的节点正是我们想要删除的节点
                temp.next = temp.next.next;
                break;
            }

            temp = temp.next;
        }
    }

1.3 代码汇总

public class SingleLinkedListTest {
    public static void main(String[] args) {
//      创建节点
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");


//      创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
//      加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
//      显示
        singleLinkedList.list();
        singleLinkedList.update(new HeroNode(1,"账账","好人卡"));
        System.out.println("************************");
        singleLinkedList.list();
        singleLinkedList.del(3);
        System.out.println("************************");
        singleLinkedList.list();

    }
}


//定义一个链表管理我们的英雄
class SingleLinkedList{
//  初始化一个头节点，头节点一般不要动
    private  HeroNode head =  new HeroNode(0,"","");

//   添加节点到单向链表
//  第一种方式 不考虑编号的顺序时
//  思路：找到当前链表的最后一个节点next指向新节点
    public void add(HeroNode heroNode){
//      因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;

//      遍历链表，找到最后，当next域是null，说明就是最后一个节点了
        while (true){
            if(temp.next ==null){
//               此时temp指向的节点已经是最后一个节点了,我们可以在这个节点后面再添加一个节点
                 temp.next = heroNode;
                 break;
            }
//           如果没有找到最后一个节点，temp就往后移动
            temp=temp.next;
        }
    }

//  遍历链表
    public void list(){
//     先判断链表是否是空
        if(head.next ==null){
            System.out.println("链表空");
            return;
        }
//      不是空，所以头结点后面会有数据
//      因为头结点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(true){
//           判断是否是空
            if(temp ==null){
                break;
            }
//          已经重写toString方法了
            System.out.println(temp);
//          输出完之后移动
            temp = temp.next;
        }
    }

//   第二种方式：在添加英雄时，根据排名将英雄插入到指定位置
    public void addByOrder(HeroNode heroNode){
//      头节点不能动，我们仍然需要一个辅助指针来帮助找到添加的位置
//      因为是单链表，我们要找到添加位置的前一个节点
        HeroNode temp = head;

        while (true){
            if(temp.next ==null){
//               说明temp已经是链表的最后了
//               此时我们只能把结点添加到最后
                temp.next=heroNode;
                break;
            }
            if(temp.next.no>heroNode.no){
//               说明我们的节点的位置应该放到temp节点与temp.next节点之间
                heroNode.next = temp.next;
                temp.next = heroNode;

                break;
            }else if(temp.next.no ==heroNode.no){
//               说明节点已经存在了，不能添加了
                System.out.println("准备添加的英雄编号"+heroNode.no+"已经存在，不能再添加");
                break;
            }
//           指针移动
            temp = temp.next;
        }

    }

//    修改，根据编号来修改，编号不可修改
    public void update(HeroNode newHeroNode){
//        判断是否是空
        if(head.next ==null){
            System.out.println("链表为空");
            return;
        }
//      定义辅助变量
        HeroNode temp = head.next;
        while (true){
            if(temp == null){
//              这种情况是最后一个节点的下一个位置，到最后一个位置的下一个位置.遍历结束了
//              这种情况其实是没找到
                System.out.println("此节点的编号并不存在，并不能修改");
                break;
            }
            if(temp.no == newHeroNode.no){
//               找到了
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
                break;
            }
            temp = temp.next;
        }

    }

//  删除节点
    public void del(int no){
//        判断是否是空
        if(head.next ==null){
            System.out.println("链表为空");
            return;
        }
//      如果no编号存在的话，temp最终会指向被删除节点no的前一个位置
        HeroNode temp = head;
        while (true){
            if(temp.next == null){
//               说明temp后面已经没有了
                System.out.println("链表中不存在"+no+"编号的人员");
               break;
            }
            if(temp.next.no == no){
//               说明我们temp节点后面的节点正是我们想要删除的节点
                temp.next = temp.next.next;
                break;
            }

            temp = temp.next;
        }
    }



}


//每个HeroNode对象就是一个结点
class HeroNode{
    public int no;            //编号（data域的一部分）
    public String name;       //名字（data域的一部分）
    public String nickname;   //昵称（data域的一部分）
    public HeroNode next; //下一个节点（next域）

//  给data域赋值
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

//  为了观察方便，我们重写toString

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

1.4 单向链表新浪面试题:查找单链表中倒数第K个结点

思路：找到返回节点，找不到返回空

编写一个方法，接受head节点，同时接收一个index
index表示是倒数第index个节点（index=1,2,3.....）
先把链表从头到尾遍历，得到链表的总长度getLength
得到size后，我们从链表的第一个开始遍历（size-index）个就可以得到（我们将head.next赋值给temp，然后temp移动size-index次便可以精确的定位）


//  查找单链表中的倒数第k个节点
    public static  HeroNode findLastIndexNode(HeroNode head,int index){
//      判断链表是否是空
        if(head.next ==null){
//          链表是空
            return  null;
        }
//      获取链表长度
        int size = getLength(head);
//      遍历，获取节点
        if(index<=0 ||index>size){
            return null;
        }

//       辅助变量
        HeroNode temp = head.next;
        for(int i=0 ; i<size-index;i++ ){
            temp = temp.next;
        }

        return temp;
    }



//  返回有效结点的个数
    public  static int  getLength (HeroNode head){
        if(head.next ==null){
//          空
            System.out.println("链表是空");
            return 0;
        }
        int length =0;
//      定义一个辅助标量
        HeroNode temp = head.next;
//      遍历链表
        while (true){
            if(temp.next ==null){
//              说明此时temp就是最后一个
                length++;
                return  length;
            }
            length++;
            temp = temp.next;

        }
    }

     System.out.println(SingleLinkedList.findLastIndexNode(singleLinkedList.getHead(),1));

1.5 腾讯面试题：单链表的反转（有点难度，但不是很大）

1.5.1 反转的思路

然后编程下面这个样子

1.5.2 代码实现


//     单链表反转
    public static  void reverseList(HeroNode head){
//        如果当前链表是空或者只有一个结点就不用反转了
        if(head.next==null || head.next.next==null){
//          不需要处理
            return;
        }

//      创建辅助指针，来遍历我们原序的链表
        HeroNode temp = head.next;
        HeroNode tempNext =null; //指向temp的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");

        while (temp !=null){
//          temp节点的下一个节点，后面有用
            tempNext = temp.next;
//          将temp的下一个节点指向新的链表的最前端
            temp.next =reverseHead.next;
//          新链表的头指针指向temp
            reverseHead.next = temp;
//          temp移动
            temp =tempNext;
        }
//       运行出来说明已经完成了
        head.next = reverseHead.next;

    }

1.6 从尾到头打印链表

方式要求1：反向遍历

方式要求2：Stack栈

1.6.1 思路分析

1.6.2 代码实现

//  利用栈的这个数据结构，将各个节点压入栈中，然后利用栈的先进后出特点，实现逆序打印效果
    public static void reversePrint(HeroNode head){
        if(head.next ==null){
//          空链表，不打印
            return;
        }

//      创建一个栈，将各个节点压入
        Stack<HeroNode>  stack = new Stack<>();
        HeroNode temp = head.next;
//      将链表中的所有节点压入栈
        while (temp!=null){
            stack.push(temp);
            temp = temp.next;
        }
//      出栈
        while (stack.size()>0){
            System.out.println(  stack.pop());
        }
    }

}

二、双向链表

案例：使用带head的双向链表实现水浒传排行榜

单向链表的缺点

单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到 temp,temp 是待删除节点的前一个节点(认真体会).

2.1 双向链表增删改查分析图解

2.2 双向链表增删改查代码实现

//创建双向链表的类
class  DoubleLinkedList{
    //  初始化一个头节点，头节点一般不要动
    private  HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead() {
        return head;
    }

    public void setHead(HeroNode head) {
        this.head = head;
    }


//  遍历的方法  没有任何改变
    public void list(){
//     先判断链表是否是空
        if(head.next ==null){
            System.out.println("链表空");
            return;
        }
//      不是空，所以头结点后面会有数据
//      因为头结点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(true){
//           判断是否是空
            if(temp ==null){
                break;
            }
//          已经重写toString方法了
            System.out.println(temp);
//          输出完之后移动
            temp = temp.next;
        }
    }

//  默认添加到双向链表的最后
    public void add(HeroNode heroNode){
//      因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;

//      遍历链表，找到最后，当next域是null，说明就是最后一个节点了
        while (true){
            if(temp.next ==null){
//               此时temp指向的节点已经是最后一个节点了,我们可以在这个节点后面再添加一个节点
                temp.next = heroNode;
                heroNode.pre = temp;
//              构成一个双向链表
                break;
            }
//           如果没有找到最后一个节点，temp就往后移动
            temp=temp.next;
        }
    }


//   修改，根据编号来修改，编号不可修改
    public void update(HeroNode newHeroNode){
//        判断是否是空
        if(head.next ==null){
            System.out.println("链表为空");
            return;
        }
//      定义辅助变量
        HeroNode temp = head.next;
        while (true){
            if(temp == null){
//              这种情况是最后一个节点的下一个位置，到最后一个位置的下一个位置.遍历结束了
//              这种情况其实是没找到
                System.out.println("此节点的编号并不存在，并不能修改");
                break;
            }
            if(temp.no == newHeroNode.no){
//               找到了
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
                break;
            }
            temp = temp.next;
        }

    }


//  删除节点，对于双线链表，我们可以直接找到要删除的节点，不需要找到删除节点的上一个
    public void del(int no){
//        判断是否是空，空的话就不用修改了
        if(head.next ==null){
            System.out.println("链表为空");
            return;
        }
//      辅助变量，最终会执行我们删除的节点
        HeroNode temp = head.next;

        while (true){
            if(temp == null){
//               说明temp后面已经没有了
                System.out.println("链表中不存在"+no+"编号的人员");
                break;
            }
            if(temp.no == no){
//               说明我们temp节点后面的节点正是我们想要删除的节点
                temp.pre.next = temp.next;
//              这样解决了我们删除最后一个的时候出现空指针异常的问题
                if(temp.next !=null){
                    temp.next.pre = temp.pre;
                }

                break;
            }

            temp = temp.next;
        }
    }




}

//每个HeroNode对象就是一个结点
class HeroNode{
    public int no;            //编号（data域的一部分）
    public String name;       //名字（data域的一部分）
    public String nickname;   //昵称（data域的一部分）
    public HeroNode next;     //下一个节点（next域）
    public HeroNode pre;      //前面的一个结点
    //  给data域赋值
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

//  为了观察方便，我们重写toString

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

测试

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();
        System.out.println("**************");

        doubleLinkedList.del(4);
        doubleLinkedList.list();
        System.out.println("**************");

        doubleLinkedList.update(new HeroNode(1,"账账","好人卡"));
        doubleLinkedList.list();
        System.out.println("**************");


    }
}

三、单向环形链表与约瑟夫问题

Josephu(约瑟夫、约瑟夫环) 问题

Josephu 问题为:

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

提示: 用一个不带头节点的循环链表来处理 Josephu

问题:

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

n = 5 , 即有5个人

k = 1, 从第一个人开始报数

m = 2, 数2下

3.1 约瑟夫问题思路分析

构建一个单向的环形链表思路

1. 先创建第一个节点, 让 first 指向该节点，并形成环形

2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可.

遍历环形链表思路

1. 先让一个辅助指针(变量) curBoy，指向first节点

2. 然后通过一个while循环遍历该环形链表即可 curBoy.next == first 结束

出圈分析思路

3.2 约瑟夫问题的代码实现

public class Josepfu {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
//      添加五个小孩节点
        circleSingleLinkedList.addBoy(5);
       circleSingleLinkedList.showBoy();
        System.out.println("*********小孩出圈测试*********");
        circleSingleLinkedList.countBoy(1,2,5);

    }
}

//  创建一个环型的单向列表
class CircleSingleLinkedList{
//    创建一个first节点
    private  Boy first = new Boy(-1);

//    添加小孩节点，构建成环型列表.输入一个数，我们就添加几个节点
    public void  addBoy(int nums){
//       先校验
        if(nums<1){
            System.out.println("num不正确");
            return;
        }

//      辅助指针，帮助构建环型链表。这个会跟着新创建的节点走
        Boy curBoy = null;

//       使用for循环创建我们的环型链表
        for(int i=1;i<=nums;i++){
//          根据编号创建小号节点
            Boy boy = new Boy(i);
//          第一个小孩有点例外
            if(i==1){
//              first指针指向第一个小孩
                first =boy;
//              第一个自己和自己成环
                first.setNext(first);
//              辞职我们的辅助指针也指向第一个
                curBoy = first;
            }else {
                curBoy.setNext(boy);
//              回环
                boy.setNext(first);
//              curBoy 移动
                curBoy=boy;
            }
        }
    }

//    遍历环型链表
    public void showBoy(){
//      先判断是否是空
        if(first == null){
            System.out.println("没有任何小孩~~~");
            return;
        }
//      first指针不能动，使用一个辅助指针
        Boy curBoy = first;
        while (true){
            System.out.println(curBoy);
//           判断是否到最后
            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){
//              此时指向了最后一个节点
                break;
            }
//          继续往下走
            helper = helper.getNext();
        }

//      在小孩报数出列之前，先让 first 和  helper 移动 k - 1次（k在这里是startNo）
        for(int j=0;j<startNo-1;j++){
            first = first.getNext();
            helper = helper.getNext();
        }

//      开始报数并出列，循环操作，直到圈中就剩下一个
        while (true){
            if(helper == first){
//               说明圈中只有一人
                System.out.println("最后剩余一人："+helper);
                break;
            }
//          让first和helper 指针同时移动 countNum-1 次
           for (int j=0;j<countNum-1;j++){
               first = first.getNext();
               helper = helper.getNext();
           }

//           出列
            System.out.println("小孩出列"+first);

//          指针变化
            helper.setNext(first.getNext());
//          first得往前走一个位置，原来的位置要删除
            first = first.getNext();

        }


    }



}




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

    @Override
    public String toString() {
        return "Boy{" +
                "no=" + no +
                '}';
    }

    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;
    }
}