数据结构与算法学习笔记(Java)

数据结构与算法学习笔记(Java)

---

程序 = 数据结构 + 算法

---

数据结构

1. 数据结构包括：线性结构和非线性结构

线性结构

1. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
2. 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构，顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。
3. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
4. 线性结构常见有：数组，队列，链表和栈。

非线性结构

1. 非线性结构包括：二维数组，多维数组，广义表，树结构，图结构。

---

稀疏数组

1. 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存改数组
2. 稀疏数组的处理方法
   1. 记录数组一共有几行几列，有多少个不同的值
   2. 把具有不同值的元素的行列及值记录在一个小规模的数组中。从而缩小程序的规模
   3. 第一行存储二维数组的总行数和总列数，一共有多少个不同的值，下面存储具体值对应的位置
      

3. 二维数组转稀疏数组思路
   1. 遍历原始的二维数组，得到有效数据的个数sum
   2. 根据sum就可以创建稀疏数组sparseArr int[sum+1][3]
   3. 将二维数组的有效数据存入到稀疏数组

4. 稀疏数组转原始二维数组的思路
	1. 先取到稀疏数组的第一行。根据第一行的数据，创建原始的二维数组
	2. 再读取稀疏数组后几行的数据，并赋给原始的二维数组即可

public class SparseArray {

    public static void main(String[] args) {
        //创建一个原始的二维数组11*11
        //0:表示没有棋子，1:表示黑子，2:表示蓝子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        //输出原始二维数组
        System.out.println("原始的二维数组。。。");
        for (int[] row: chessArr1) {
            for (int data: row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        //将二维数组转稀疏数组
        //1.先遍历二维数组，得到非0数据的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0){
                    sum++;
                }
            }
        }
        //2.创建对应的稀疏数组
        int sparseArr[][] = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        //遍历二维数组，将非0的值存放sparseArr中
        int count  = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr1[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("得到的稀疏数组为。。。");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
        }
        /**
         * 将稀疏数组-->恢复成原始二维数组
         * 1.先读取稀疏数组第一行，根据第一行的数据，创建原始的二维数组
         * 2.再读取稀疏数组后几行数据，并赋值给原始二维数组
         */
        //创建原始二维数组
        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        System.out.println("恢复后的二维数组。。。");
        for (int[] row: chessArr2) {
            for (int data: row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        /**
         * 1.稀疏数组保存到文件
         * 2.读取文件恢复稀疏数组
         */
        //保存至文件
        File file = new File("E:\\sparseArr.txt");
        try {
            if (!file.exists()){
                file.createNewFile();
            }
            FileWriter fileWriter = new FileWriter(file);
            BufferedWriter bw = new BufferedWriter(fileWriter);
            for (int i = 0; i < sparseArr.length; i++) {
                bw.write(sparseArr[i][0]+ ","+sparseArr[i][1]+","+sparseArr[i][2]);
                bw.newLine();
                bw.flush();
            }
        }catch (IOException e){
            System.out.println(e);
        }
        //读取文件内容
        String result = null;
        try {
            StringBuilder builder = new StringBuilder();
            //构造一个BufferedReader类来读取文件
            BufferedReader br = new BufferedReader(new FileReader(file));
            String str = null;
            while ((str = br.readLine()) != null){
                builder.append(str).append(";");
            }
            result = builder.deleteCharAt(builder.lastIndexOf(";")).toString();
        }catch (IOException e){
            System.out.println(e);
        }
        String array[]  = result.split(";");
        int sparseArr1[][] = new int[array.length][3];
        for (int i = 0; i < array.length; i++) {
            String str[] = array[i].split(",");
            sparseArr1[i][0] = Integer.parseInt(str[0]);
            sparseArr1[i][1] = Integer.parseInt(str[1]);
            sparseArr1[i][2] = Integer.parseInt(str[2]);
        }
        System.out.println("读取文件恢复的稀疏数组。。。");
        for (int[] row: sparseArr1) {
            for (int data: row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}

队列

1. 队列是一个有序列表，可以用数组或是链表来实现
2. 遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入的要后取出

//代码实现
public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建队列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop){
            System.out.println("s(show): 显示队列");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加数据到队列");
            System.out.println("g(get): 从队列取数据");
            System.out.println("h(head): 查看队列头的数据");
            key = scanner.next().charAt(0);  //接收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.println("输入一个数字");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\t", res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\t", res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                 default:
                    break;
            }
        }
        System.out.println("程序退出。。。");
    }
}

//使用数组模拟队列-编写一个ArrayQueue类
class ArrayQueue{

    private int maxSize; //表示数组最大容量

    private int front; //队列头

    private int rear;  //队列尾

    private int[] arr; //用于存放数据，模拟队列

    //创建队列的构造器
    public ArrayQueue(int maxSize){
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = -1;  //指向队列头部，分析出指向队列头的前一个位置
        rear = -1;  //指向队列尾，指向队列尾的数据(队列最后一个数据)
    }

    //判断队列是否满
    public boolean isFull(){
        return rear == maxSize -1;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int n){
        //判断队列是否满
        if (isFull()){
            System.out.println("队列满，不能加入数据");
            return;
        }
        rear++;  //rear后移
        arr[rear] = n;
    }

    //获取队列数据，出队列
    public int getQueue(){
        if (isEmpty()){
            //抛出异常
            throw new RuntimeException("队列为空，不能取数据");
        }
        front++;
        return arr[front];
    }

    //显示所有数据
    public void showQueue(){
        //遍历
        if (isEmpty()){
            System.out.println("队列为空，没有数据");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    //显示队列的头数据，不是取出数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }
        return arr[front + 1];
    }
}

问题分析并优化

1. 目前数组使用一次就没能用，没有达到复用的效果
2. 将这个数组使用算法，改进成一个环形队列，取模：%
   1. front变量含义做一个调整：front就指向为队列的第一个元素，也就是说arr[front]就是队列的第一个元素，front初始值=0
   2. rear变量的含义做一个调整：rear指向队列最后一个元素的后一个位置，因为希望空出一个空间作为约定，rear初始值=0
   3. 当队列满时，条件是(rear + 1) % maxSize == front
   4. 队列为空的条件，rear = front
   5. 队列中有效的数据个数：(rear + maxSize - front) % maxSize

public class CircleArrayQueueDemo {

    public static void main(String[] args) {
        System.out.println("测试数组模拟环形队列。。。");
        //创建队列
        CircleArray queue = new CircleArray(4);
        char key = ' '; //接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop){
            System.out.println("s(show): 显示队列");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加数据到队列");
            System.out.println("g(get): 从队列取数据");
            System.out.println("h(head): 查看队列头的数据");
            key = scanner.next().charAt(0);  //接收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.println("输入一个数字");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\t", res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\t", res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出。。。");
    }
}

class CircleArray{


    private int maxSize; //表示数组最大容量

    /**
     *  front变量含义做一个调整：front就指向为队列的第一个元素，
     *  也就是说arr[front]就是队列的第一个元素，front初始值=0
     */
    private int front; //队列头

    /**
     * rear变量的含义做一个调整：rear指向队列最后一个元素的后一个位置，
     * 因为希望空出一个空间作为约定，rear初始值=0
     */
    private int rear;  //队列尾

    private int[] arr; //用于存放数据，模拟队列

    public CircleArray(int arrMaxSize){
        this.maxSize = arrMaxSize;
        arr = new int[maxSize];
    }

    //判断队列是否满
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return rear == front;
    }

    //添加数据到队列
    public void addQueue(int n){
        //判断队列是否满
        if (isFull()){
            System.out.println("队列满，不能加入数据");
            return;
        }
        arr[rear] = n;
        rear = (rear + 1) % maxSize;  //rear后移
    }

    //获取队列数据，出队列
    public int getQueue(){
        if (isEmpty()){
            //抛出异常
            throw new RuntimeException("队列为空，不能取数据");
        }
        //这里需要分析出front是指向队列的第一个元素
        /**
         * 1. 先把front对应的值保留到一个临时变量
         * 2. 将front后移,考虑取模
         * 3. 将临时保存的变量返回
         */
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    //显示所有数据
    public void showQueue(){
        //遍历
        if (isEmpty()){
            System.out.println("队列为空，没有数据");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    //当前队列有效数据的个数
    public int size(){
        return (rear + maxSize - front) % maxSize;
    }

    //显示队列的头数据，不是取出数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，没有数据");
        }
        return arr[front];
    }
}

链表(Linked List)

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

思路

1. 添加
   1. 创建一个head头节点，作用就是表示单链表的头
   2. 后面每添加一个节点，就直接添加到链表的最后

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);
        //显示
        singleLinkedList.list();
    }
}

class SingleLinkedList{
    //定义一个头节点,不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

    //添加节点到单向链表
    //思路:当不考虑编号顺序时，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 list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此我们需要一个辅助变量temp
        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;
    }

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

2. 按编号的顺序添加
   1. 首先找到新添加节点的位置，是通过辅助变量(指针)，通过变量来完成
   2. 新节点.next = temp.next
   3. 将temp.next = 新节点

public void addByOrder(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量temp
        //因为是单链表，找的temp是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; //标识添加的编号是否存在
        while (true){
            if (temp.next == null){
                break;  //说明temp已经在链表最后
            }
            if (temp.next.no > heroNode.no){  //位置找到，就在temp的后面插入
                break;
            }else if (temp.next.no == heroNode.no){  //添加heroNode的编号已经存
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.printf("准备插入的编号%d 已经存在，不能加入\n", heroNode.no);
        }else {
            //插入到链表中，temp后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

3. 单链表修改节点

//根据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 == null){
                break;  //已经遍历完链表
            }
            if (temp.no == newHeroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else {
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

4. 单链表删除节点

//找到待删除节点的前一个节点
//temp.next = temp.next.next 被删除的节点将不会有其他引用指向，会被垃圾回收机制回收
    public void del(int no){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //删除
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

5. 获取链表节点个数

//获取链表节点个数(带头节点的链表，需要不统计头节点)
    public static int getLenth(HeroNode heroNode){
        if (heroNode.next == null){
            return 0;
        }
        int length = 0;
        HeroNode cur = heroNode.next;
        while (cur != null){
            length ++;
            cur = cur.next;
        }
        return length;
    }
}

6. 查找单链表中倒数第k个节点

/**
     * 查找单链表中倒数第k个节点
     * 1.编写一个方法，接收head节点，同时接收一个index
     * 2.index表示倒数第index个节点
     * 3.先把链表从头到尾遍历，得到链表的总长度
     * 4.得到size后，从第一个节点遍历size-index个，就可以得到
     * @param
     * @return
     */
    public static HeroNode findLastIndexNode(HeroNode head, int index){
        if (head.next == null){
            return null;  //没有找到
        }
        //获取链表长度
        int size = getLenth(head);
        //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;
    }

7. 单链表反转

/**
     * 将链表反转
     * 思路:
     * 1.先定义一个节点 reverseHead
     * 2.从头到尾遍历原来的链表，没遍历一个节点，将其取出，并放在新的链表reverseHead的前段
     * 3.原来的链表的head.next = reverseHead.next
     */
    public static void  reversetList(HeroNode head){
        //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        if (head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助指针，帮助遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;  //指向当前节点的下一个节点
        HeroNode reverseHead = new HeroNode(0, "", "");

        while (cur != null){
            next = cur.next; // 保存当前节点的下一个节点，后面需要使用
            cur.next = reverseHead.next;  //将cur的下一个节点指向新的链表的最前段
            reverseHead.next = cur;
            cur = next;  //让cur后移
        }
        //将head.next指向reverseHead.next, 实现单链表反转
        head.next = reverseHead.next;
    }

8. 逆序打印单链表

/**
     * 单链表逆序打印
     * 利用栈先进后出的特点实现
     */
    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());
        }
    }

双向链表

public class DoubleLinkedListDemo {

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

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        /*doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);*/

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

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

        //删除
        doubleLinkedList.del(4);
        System.out.println("删除后的链表");
        doubleLinkedList.list();
    }
}

/**
 * 单向链表和双向链表的区别:
 * 1.单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找
 * 2.单向链表不能自我删除，需要辅助节点，而双向链表，则可以自我删除
 */
class DoubleLinkedList{
    //定义一个头节点,不存放具体数据
    private HeroNode2 head = new HeroNode2(0, "", "");

    public HeroNode2 getHead() {
        return head;
    }

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

    //找到待删除节点的前一个节点
    //temp.next = temp.next.next 被删除的节点将不会有其他引用指向，会被垃圾回收机制回收
    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){
                return;
            }
            if (temp.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //删除
            temp.pre.next = temp.next;
            //如果删除的是最后一个节点，不加判断会报空指针
            if (temp.next != null){
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

    //根据no修改节点信息
    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;
        }
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else {
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

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

    //显示遍历链表
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此我们需要一个辅助变量temp
        HeroNode2 temp = head.next;
        while (true){
            //判断是否到链表最后
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }
}

class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;  //指向下一个节点
    public HeroNode2 pre;  //指向前一个节点

    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

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

约瑟夫问题

public class Josepfu {

    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();
        circleSingleLinkedList.countBoy(1,2, 5);
    }
}

//创建环形单向链表
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;  //让curBoy指向第一个节点
            }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 < 0 || startNo > nums){
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        //创建辅助指针，帮助完成小孩出圈
        Boy helper = first;
        //helper指针事先应该指向链表最后一个节点
        while (true){
            if (helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }
        //从第几个节点开始出圈，先让first 和helper移动 startNo -1 次
        for (int i = 1; i <= startNo -1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        while (true){
            if (helper == first){  //环形链表只有一个节点
                break;
            }
            //数到第几个出圈，先让first 和helper移动 countNum -1 次
            for (int i = 1; i <= countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //此时first为即将出圈的节点
            System.out.printf("小孩%d出圈\n", first.getNo());
            //移除节点
            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;
    }
}