数据结构与算法【Java】02---链表

前言

数据 data 结构(structure)是一门 研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构才可以编写出更加漂亮,更加有效率的代码。

• 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决.
• 程序 = 数据结构 + 算法
• 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位

我会用数据结构与算法【Java】这一系列的博客记录自己的学习过程，如有遗留和错误欢迎大家提出，我会第一时间改正！！！

注：数据结构与算法【Java】这一系列的博客参考于B站尚硅谷的视频，视频原地址为【尚硅谷】数据结构与算法（Java数据结构与算法）

上一篇文章数据结构与算法【Java】01---稀疏数组与队列

接下来进入正题!

1、链表简介

1.1、链表的介绍和存储结构

链表是有序的列表，但是它在内存中是存储如下

1.2、链表的特点：

1. 链表是以节点的方式来存储, 是链式存储
2. 每个节点包含 data 域， next 域：指向下一个节点.
3. 如图：发现 链表的各个节点不一定是连续存储.
4. 链表分 带头节点的链表和 没有头节点的链表，根据实际的需求来确定

1.3、链表的逻辑结构

2、单链表

2.1、单链表的增删改查

使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作

1. 第一种方法在添加英雄时，直接添加到链表的尾部
   
   思路分析示意图:
   
   
   
   代码实现：

//添加节点到单向链表(在最后添加)
//思路，当不考虑编号顺序时
//1. 找到当前链表的最后节点
//2. 将最后这个节点的next 指向 新的节点
public void add(HeroNode heroNode){
    //因为head节点不能动，因此我们需要一个辅助变量 temp
    HeroNode temp  =head;
    //遍历链表找到最后
    while (true){
        //找到链表的最后
        if(temp.next == null){
            break;
        }
        //如果没有找到最后,将temp后移
        temp = temp.next;
    }
    //当退出while循环时，temp就指向了链表的最后
    //将最后这个节点的next 指向 新的节点
    temp.next = heroNode;
}

1. 第二种方式在添加英雄时， 根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)
   
   思路的分析示意图:
   
   
   
   代码实现：

//第二种方式在添加英雄时，根据排名将英雄插入到指定位置
//(如果有这个排名，则添加失败，并给出提示)
public void addByOrder(HeroNode heroNode){
    //因为head节点不能动，因此我们需要一个辅助变量 temp来帮助找到添加位置
    //因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
    HeroNode temp = head;
    //标志添加的标号是否存在，默认为false
    boolean flag = false;
    while (true){
        if(temp.next == null){//在链表的最后
            break;
        }
        if(temp.next.no > heroNode.no){//位置找到，就在temp的后面插入
            break;
        }else if(temp.next.no == heroNode.no ){//说明要添加的heroNode的编号已经存在
            flag = true;
            break;
        }
        temp = temp.next;//后移，遍历当前链表
    }
    //判断flag的值
    if(flag){
        System.out.printf("要添加的节点编号%d已经存在，不能添加\n",heroNode.no);
    }else {
        //将要添加的节点插入到链表中，temp的后边
        heroNode.next = temp.next;
        temp.next = heroNode;

    }
}

1. 修改节点功能

   思路：

   (1) 先找到该节点，通过遍历

   (2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname

   代码实现：

    //修改节点的信息，根据编号来修改，所以no不能变
    //说明
    //1. 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag  = false;//表示是否找到该节点
        while (true){
            if(temp.next == null){//链表遍历结束
                break;
            }
            if(temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickname  = newHeroNode.nickname;
        } else {
            //没找到这个节点
            System.out.printf("没有找到编号为%d的节点，不能修改\n",newHeroNode.no);
        }

    }

1. 删除节点
   
   思路分析的示意图:
   
   
   
   代码实现:

//删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明我们在比较时，是temp.next.no 和  需要删除的节点的no比较
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;//是否找到

        while (true){
            if(temp.next == null){//遍历结束
                break;
            }
            if(temp.next.no == no){
                //找到了待删除节点的前一个节点temp
                flag = true;
                break;
            }
        temp = temp.next;
        }
        //判断flag
        if(flag){
            //找到
            //可以删除
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的节点%d不存在,不能删除\n",no);
        }

    }

1. 显示链表

    //显示链表（遍历）
    public void list(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，所以需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //没到最后就输出节点的信息
            System.out.println(temp);
            //将temp后移才能输出下一个数据
            temp = temp.next;
        }

    }

整体代码

public class SingleLinkedListDemo {

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

        //加入按照编号的顺序
        System.out.println("有序加入");
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero3);

        //显示
        singleLinkedList.list();

        //测试修改节点
        //创建一个新的节点
        HeroNode newHero = new HeroNode(2,"卢本伟","伞兵一号");
        singleLinkedList.update(newHero);
        System.out.println("修改后的链表");
        singleLinkedList.list();

        //测试删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(8);
        System.out.println("删除后的链表");
        singleLinkedList.list();

    }

}

//定义SingleLinkedList来管理我们的英雄
class  SingleLinkedList{
    //先初始化一个头节点，头节点不要动，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //返回头节点
    public HeroNode getHead() {
        return head;
    }

    //添加节点到单向链表(在最后添加)
    //思路，当不考虑编号顺序时
    //1. 找到当前链表的最后节点
    //2. 将最后这个节点的next 指向 新的节点
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp  =head;
        //遍历链表找到最后
        while (true){
            //找到链表的最后
            if(temp.next == null){
                break;
            }
            //如果没有找到最后,将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next 指向 新的节点
        temp.next = heroNode;
    }

    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp来帮助找到添加位置
        //因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        //标志添加的标号是否存在，默认为false
        boolean flag = false;
        while (true){
            if(temp.next == null){//在链表的最后
                break;
            }
            if(temp.next.no > heroNode.no){//位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no == heroNode.no ){//说明要添加的heroNode的编号已经存在
                flag = true;
                break;
            }
            temp = temp.next;//后移，遍历当前链表
        }
        //判断flag的值
        if(flag){
            System.out.printf("要添加的节点编号%d已经存在，不能添加\n",heroNode.no);
        }else {
            //将要添加的节点插入到链表中，temp的后边
            heroNode.next = temp.next;
            temp.next = heroNode;

        }
    }

    //修改节点的信息，根据编号来修改，所以no不能变
    //说明
    //1. 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag  = false;//表示是否找到该节点
        while (true){
            if(temp.next == null){//链表遍历结束
                break;
            }
            if(temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickname  = newHeroNode.nickname;
        } else {
            //没找到这个节点
            System.out.printf("没有找到编号为%d的节点，不能修改\n",newHeroNode.no);
        }

    }

    //删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明我们在比较时，是temp.next.no 和  需要删除的节点的no比较
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;//是否找到

        while (true){
            if(temp.next == null){//遍历结束
                break;
            }
            if(temp.next.no == no){
                //找到了待删除节点的前一个节点temp
                flag = true;
                break;
            }
        temp = temp.next;
        }
        //判断flag
        if(flag){
            //找到
            //可以删除
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的节点%d不存在,不能删除\n",no);
        }

    }

    //显示链表（遍历）
    public void list(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，所以需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //没到最后就输出节点的信息
            System.out.println(temp);
            //将temp后移才能输出下一个数据
            temp = temp.next;
        }

    }

}

//定义一个HeroNode，每一个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;   //指向下一个节点

    //构造器
    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 + '\'' +
                '}';
    }
}

测试结果

2.2、单链表的常见问题

1. 求单链表中有效节点的个数

   代码实现：

   //方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
       /**
        * @param head 链表的头节点
        * @return 返回的就是有效节点的个数
        */
       public static int getLength(HeroNode head){
           if(head.next == null){
               //这是一个带头节点的空链表
               return 0;
           }
           int length = 0;
           //定义一个辅助的变量，没有统计头节点
           HeroNode cur = head.next;
           while (cur != null){
               length++;
               cur = cur.next;//遍历
           }
           return length;
       }
   

   测试结果：

   //测试获取到单链表的节点的个数
   System.out.println("获取到单链表的节点的个数为："+ getLength(singleLinkedList.getHead()));
   

1. 查找单链表中的倒数第 k 个结点

   代码实现：

   //查找单链表中的倒数第k个结点 【新浪面试题】
       //思路
       //1. 编写一个方法，接收head节点，同时接收一个index
       //2. index 表示是倒数第index个节点
       //3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
       //4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到(假设总共有5个，要倒数第2个，就遍历5-2个(最开始在1号节点的位置head.next))
       //5. 如果找到了，则返回该节点，否则返回null
       public static HeroNode findLastIndexNode(HeroNode head,int index){
           //判断，如果链表为空，返回null
           if(head.next == null){
               return null;
           }
           //第一次遍历得到节点的个数
           int size = getLength(head);
           //第二次遍历(size-index)，就是我们倒数的第k个节点
           //先做一个index的校验
           if(index <=0 || index>size){
               return null;
           }
           //定义一个辅助变量,for循环定位到倒数的index
           HeroNode cur = head.next;
           for (int i = 0; i < size-index; i++) {
               cur = cur.next;
           }
           return cur;
       }
   
   

   测试结果

   //测试查找单链表中的倒数第k个结点 【新浪面试题】
   HeroNode res = findLastIndexNode(singleLinkedList.getHead(), 3);
   System.out.println("res="+res);
   

1. 单链表的反转

   思路分析：

代码实现：

//将单链表反转
// 思路:
//       1. 先定义一个节点 reverseHead = new HeroNode();
//       2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
//       3. 原来的链表的head.next = reverseHead.next
    public static void reverseList(HeroNode head) {
        //如果当前链表为空或者只有一个节点就无需反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        //先定义一个辅助的指针，帮助我们遍历原来的链表
        HeroNode cur = head.next;
        HeroNode nextOne = null;//指向当前节点【cur】的的下一个节点
        HeroNode reverseHead = new HeroNode(0, "", "");
        //从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
        while (cur != null) {
            nextOne = cur.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
            //如果不使用next，那么遍历取出当前节点就会与后一个节点断开连接，就不能取出后一个节点了
            cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur;//将cur连接到新的链表上
            cur = nextOne;//后移,指向当前节点【cur】的的下一个节点
        }
        //原来的链表的head.next = reverseHead.next,实现单链表的反转
        head.next = reverseHead.next;

    }

测试结果：

//测试将单链表反转
System.out.println("=================当前链表的形式==================");
singleLinkedList.list();

System.out.println("=================反转链表的形式==================");
reverseList(singleLinkedList.getHead());
singleLinkedList.list();

1. 从尾到头打印单链表

   思路分析：

代码实现：

//逆序打印单链表
    //方式一： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
    //方式二：可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果.
    public static void reversePrint(HeroNode head){
        if(head.next == null){
            return;//空链表，无法逆序打印单链表
        }
        //创建一个栈，将各个节点压入栈中
        Stack<HeroNode> stack = new Stack<>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈中
        while (cur != null){
            stack.push(cur);
            cur = cur.next;//后移压入下一个节点
        }
        //将栈中的节点进行打印
        while (stack.size()>0){
            System.out.println(stack.pop());//先进后出
        }

    }

测试结果：

 //测试逆序打印单链表
 System.out.println("=================逆序打印单链表(没有改变链表的结构)==================");
 reversePrint(singleLinkedList.getHead());

3、双向链表

3.1、双向链表的增删改查

使用带 head 头的双向链表实现 –水浒英雄排行榜

• 单向链表的缺点分析:

• 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。

• 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除

​ 时节点，总是找到 temp,temp 是待删除节点的前一个节点(认真体会).

• 分析双向链表如何完成遍历，添加，修改和删除：

  思路分析：

代码实现

package com.qjd.linkedlist;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //测试
        System.out.println("双向链表的测试");
        //先创建节点
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
        //创建一个双向链表对象
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        //修改
        HeroNode2 newHeroNode = new HeroNode2(4,"公孙胜","入云龙");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况");
        doubleLinkedList.list();

        //删除
        doubleLinkedList.del(3);
        System.out.println("删除后的链表情况");
        doubleLinkedList.list();

    }
}

//创建一个创建一个双向链表的类
class DoubleLinkedList{
    //先初始化一个头节点，头节点不要动，不存放具体的数据
    private HeroNode2 head = new HeroNode2(0,"","");

    //返回头节点
    public HeroNode2 getHead() {
        return head;
    }

    //遍历双向链表的方法
    //显示链表（遍历）
    public void list(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，所以需要一个辅助变量来遍历
        HeroNode2 temp = head.next;
        while (true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //没到最后就输出节点的信息
            System.out.println(temp);
            //将temp后移才能输出下一个数据
            temp = temp.next;
        }

    }

    //添加（到链表最后）
    public void add(HeroNode2 heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode2 temp  =head;
        //遍历链表找到最后
        while (true){
            //找到链表的最后
            if(temp.next == null){
                break;
            }
            //如果没有找到最后,将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //构成双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //修改一个节点，与单向链表一样
    public void update(HeroNode2 newHeroNode){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        //定义一个辅助变量
        HeroNode2 temp = head.next;
        boolean flag  = false;//表示是否找到该节点
        while (true){
            if(temp == null){//链表遍历结束
                break;
            }
            if(temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickname  = newHeroNode.nickname;
        } else {
            //没找到这个节点
            System.out.printf("没有找到编号为%d的节点，不能修改\n",newHeroNode.no);
        }

    }

    //删除节点
    //对于双向链表，我们可以直接找到要删除的节点，自我删除
    public void del(int no){
        //判断当前链表是否为空
        if(head.next == null){
            System.out.println("链表为空，无法删除");
            return;
        }

        HeroNode2 temp = head.next;
        boolean flag = false;//是否找到

        while (true){
            if(temp == null){//遍历结束
                break;
            }
            if(temp.no == no){
                //找到了待删除节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //判断flag
        if(flag){
            //找到
            //可以删除
            temp.pre.next = temp.next;
            //如果删除的是最后一个节点就不需要temp.next.pre = temp.pre;，否则会出现空指针异常
            if(temp.next !=null){temp.next.pre = temp.pre;}

        }else {
            System.out.printf("要删除的节点%d不存在,不能删除\n",no);
        }

    }

}

//定义一个HeroNode，每一个HeroNode对象就是一个节点
class HeroNode2 {
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;   //指向下一个节点,默认为空null
    public HeroNode2 pre;   //指向上一个节点,默认为空null

    //构造器
    public HeroNode2(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 + '\'' +
                '}';
    }
}

测试结果：

3.2、双向链表顺序添加

代码实现：

//顺序添加
public void addByOrder(HeroNode2 heroNode){
    //因为head节点不能动，因此我们需要一个辅助变量 temp来帮助找到添加位置
    //因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
    HeroNode2 temp = head;
    //标志添加的标号是否存在，默认为false
    boolean flag = false;
    while (true){
        if(temp.next == null){//在链表的最后
            break;
        }
        if(temp.next.no > heroNode.no){//位置找到，就在temp的后面插入
            break;
        }else if(temp.next.no == heroNode.no ){//说明要添加的heroNode的编号已经存在
            flag = true;
            break;
        }
        temp = temp.next;//后移，遍历当前链表
    }
    //判断flag的值
    if(flag){
        System.out.printf("要添加的节点编号%d已经存在，不能添加\n",heroNode.no);
    }else {
        //将要添加的节点插入到链表中，temp的后边
        heroNode.next = temp.next;
        temp.next = heroNode;
        temp.next.pre = heroNode;
        heroNode.pre = temp;

    }

}

测试结果：

//按顺序添加
System.out.println("按顺序添加");
doubleLinkedList.addByOrder(hero2);
doubleLinkedList.addByOrder(hero4);
doubleLinkedList.addByOrder(hero1);
doubleLinkedList.addByOrder(hero3);
doubleLinkedList.list();

4、单向环形链表

4.1、单向环形链表介绍

4.2、单向环形链表应用场景

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

• Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数

  到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由

  此产生一个出队编号的序列。

• 提示：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结

  点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直

  到最后一个结点从链表中删除算法结束。

4.3、Josephu问题的实现

• 约瑟夫问题的流程图示意图

• 约瑟夫问题创建环形链表的思路分析图

• 约瑟夫问题小孩出圈的思路分析图

代码实现

package com.qjd.linkedlist;

public class Josepfu {
    public static void main(String[] args) {
        //测试
        System.out.println("================创建环形链表=================");
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);//加入5个小孩节点
        circleSingleLinkedList.showBoy();

        //测试小孩出圈是否正确
        System.out.println("================小孩出圈=================");
        circleSingleLinkedList.countBoy(1,2,5);

    }
}

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

        }
    }

    //遍历当前的环形链表
    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();//后移
        }
    }

    //根据用户的输入，计算出小孩出圈的顺序
    /**
     *
     * @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次，实现从第k个小孩开始报数
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        //当小孩报数时，让first 和 helper 指针同时 的移动  m  - 1 次, 然后出圈
        //这里是一个循环操作，直到圈中只有一个节点
        while (true){
            if (helper == first){
                //圈中只有一个节点
                break;
            }
            //让 first 和 helper 指针同时 的移动 countNum - 1
            for (int i = 0; i < countNum - 1; i++) {
                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;//指向下一个节点，默认是空

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

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

测试结果：

到这里关于链表的数据结构与算法就结束了，如果大家觉得有问题欢迎提出꒰ঌ( ⌯' '⌯)໒꒱