哈士奇发布数据结构【数组、链表、队列、栈的基本使用】

1、稀疏数组

1.1、应用场景

棋盘、扫雷、地图等等

1.2、简单代码示例【棋盘示例，后期可以使用IO进行转换为文件保存】

// 创建一个原始的二维数组 11*11
// 0:表示没有棋子，1：表示黑子，2：表示白子
int chessArray1[][] = new int[11][11];
chessArray1[1][2] = 1;
chessArray1[2][3] = 2;
// 输出原始的二维数组
System.out.println("---------原始的二维数组---------");
for (int[] row : chessArray1) {
    for (int data : row) {
        System.out.printf("%d\t", data);
    }
    System.out.println();
}
// 将二维数组转成稀疏数组
// 1.先遍历二维数组 得到非0数据的个数
int sum = 0;
for (int i = 0; i < chessArray1.length; i++) {
    for (int j = 0; j < chessArray1.length; j++) {
        if (chessArray1[i][j] != 0) {
            sum++;
        }
    }
}
// 2.创建对应的稀疏数组【计算出sum的值才能创建，因为这样才能知道稀疏数组的行数】
int sparseArr[][] = new int[sum+1][3];
// 给稀疏数组赋值,初始化第一行数据
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
// 遍历二维数组，将非0的值存放到sparseArr中
// 设置一个计数器count，记录是存储第几个棋子
int count = 0;
for (int i = 0; i < chessArray1.length; i++) {
    for (int j = 0; j < chessArray1.length; j++) {
        if (chessArray1[i][j] != 0) {
            count++;
            sparseArr[count][0] = i;
            sparseArr[count][1] = j;
            sparseArr[count][2] = chessArray1[i][j];
        }
    }
}

// 3.输出稀疏数组的形式
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]);
}

// 4.将稀疏数组 恢复成 原始的二维数组
/**
         * （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];
}

// 5.输出恢复后的二维数组
System.out.println("---------恢复后的二维数组---------");
for (int[] row : chessArr2) {
    for (int data : row) {
        System.out.printf("%d\t", data);
    }
    System.out.println();
}

2、队列

2.1、应用场景

排队

2.2、简单代码实例【数组队列】

// 使用数组模拟队列 编写一个ArrayQueue类
public class ArrayQueue {
    private int maxSize; // 表示数组的最大容量
    private int front; // 队列头
    private int rear; // 队列尾
    private int[] arr; // 该数组用于存储数据，模拟队列

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

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

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

    // 添加数据到队列中
    public boolean addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列已满，数据无法加入");
            return false;
        }
        System.out.println("333");
        this.arr[++rear] = n; // 让rear后移,并加入数据
        return true;
    }

    // 取出队列头部数据
    public int getQueueFront() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列已空，无法获取数据");
        }
        return this.arr[front++]; // 让front后移，获取数据
    }

    // 获取队列头部数据
    public int headQueueFront() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列已空，无法获取头部数据");
        }
        return this.arr[front+1];
    }

    // 显示队列的所有数据
    public void showQueueData() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列已空，无法显示数据");
        }
        // 遍历队列
        for (int i = 0; i < this.arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, this.arr[i]);
        }
    }
}

2.3、简单代码实例【循环数组队列】

// 使用数组模拟循环队列 编写一个CycleArrayQueue类 留出一个数组元素空位
public class CycleArrayQueue {
    private final int maxSize; // 表示数组的最大容量
    private int front; // 队列头 初始值为0 指向队列第一个元素
    private int rear; // 队列尾 初始值为0 指向队列的最后一个元素的后一个位置
    private final int[] arr; // 该数组用于存储数据，模拟队列

    // 创建循环队列的构造器
    public CycleArrayQueue(int arrMaxSize) {
        this.maxSize = arrMaxSize;
        this.arr = new int[maxSize];
    }

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

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

    // 添加数据到循环队列中
    public boolean addQueue(int n) {
        // 判断队列是否满
        if (isFull()) {
            System.out.println("队列已满，数据无法加入");
            return false;
        }
        // 将数据直接加入循环队列
        arr[rear] = n;
        // 后移rear
        rear = (rear + 1) % maxSize;
        return true;
    }

    // 取出循环队列头部数据
    public int getQueueFront() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列已空，无法获取数据");
        }
        return this.arr[front]; // 让front后移，获取数据
    }

    // 获取循环队列头部数据
    public int headQueueFront() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列已空，无法获取头部数据");
        }
        // 这里需要分析出front是指向队列的第一个元素
        // 先将front对应的值保留到一个临时变量value中
        int value = this.arr[front];
        // 再者将front进行后移
        front = (front + 1) % maxSize;
        // 最后取出临时变量
        return value;
    }

    // 显示循环队列的所有数据
    public void showQueueData() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列已空，无法显示数据");
        }
        // 遍历队列
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, this.arr[i % maxSize]);
        }
    }

    // 获取循环队列的有效数据长度
    public int size() {
        return (rear - front + maxSize) % maxSize;
    }
}

3、单链表

3.1、应用场景

• 对线性表的长度或者规模难以估计

• 频繁做插入删除操作

• 构建动态性比较强的线性表

3.2、创建链表节点【可以将节点中的属性改成自己想要的】

// 定义HeroNode，每一个HeroNode对象就是一个节点
public 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 + '\'' +
                '}';
    }
}

3.3、创建链表及操作方法【基础】

import java.util.Stack;

// 创建链表，进行管理相应的节点
public class SingleLinkedList {
    // 初始化头结点，头结点不带数据
    private final HeroNode head = new HeroNode(0, "", "");

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

    /**
     * 添加节点到单向链表
     * 当不考虑编号顺序时
     * - 找到当前链表的最后节点
     * - 将最后这个节点的next指向新的节点
     * @param heroNode 要添加的节点
     */
    public void add(HeroNode heroNode) {
        // 由于头结点【head】不能动，所以我们需要一个辅助引用temp
        HeroNode temp = head;
        // 遍历链表，找到最后
        while (temp.next != null) {
            // 当遍历到节点的next等于null,则遍历到了最后
            // 如果没有找到最后，就将temp后移
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后
        temp.next = heroNode;
    }

    /**
     * 当考虑编号顺序时
     * - 首先找到新添加节点的位置，通过辅助引用遍历
     * - 新的节点的next = 辅助引用的next
     * - 将辅助引用的next = 新的节点
     * @param heroNode 要添加的节点
     */
    public void addBySort(HeroNode heroNode) {
        // 因为头结点不能动，因此我们仍然通过一个辅助引用来帮助我们找到添加的位置
        // 由于此结构为单链表，因此我们找到辅助引用是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        // 设置标志添加的编号是否存在，默认为false
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                // 说明辅助引用已经到了链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) {
                // 位置找到，就在辅助引用的后面进行插入
                break;
            } else if (temp.next.no == heroNode.no) {
                // 说明想要添加的节点已经存在
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 判断flag标志的值
        if (flag) {
            // 不能添加，编号已经存在
            System.out.printf("待插入的节点编号 %d 已经存在，无法进行插入\n", heroNode.no);
        } else {
            // 在辅助引用后面插入节点
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 修改节点信息，根据编号修改，及编号不能修改
    public void updateByNo(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;
        }
        // 根据flag判断是否找到了要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            // 找不到要修改的编号
            System.out.printf("没有找到编号为 %d 的节点，不能进行修改\n", newHeroNode.no);
        }
    }

    /**
     * 从单链表中删除一个节点
     * 思路
     * - 我们先找到需要删除的这个节点的前一个节点，由于head不能动，使用临时引用
     * - temp.next = temp.next.next
     * - 被删除的节点将不会有其他引用指向，会被垃圾回收机制进行回收
     * @param no 要删除节点的编号
     */
    public void del(int no) {
        HeroNode temp = head;
        // 标志是否找到了被删除编号的节点
        boolean findFlag = false;
        while (true) {
            // 说明已经遍历到了单链表的最后，没有找到待删除节点
            if (temp.next == null) {
                break;
            }
            // 如果临时引用的下一个节点的编号等于待删除节点的编号，那么就是找到了待删除节点的前一个节点，即临时引用
            if (temp.next.no == no) {
                // 设置标志为true
                findFlag = true;
                break;
            }
            temp = temp.next;
        }
        if (findFlag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("没有找到待删除编号为 %d 的节点，无法进行删除\n", no);
        }
    }

    // 显示链表【遍历链表】
    public void showSingleLinkedList() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法遍历");
            return;
        }
        // 如果不为空，则创建一个辅助引用temp，因为头结点不能动
        HeroNode temp = head.next;
        while (temp != null) {
            // 判断是否遍历到了链表的最后
            // 输出节点的信息
            System.out.println(temp);
            // 将temp进行后移，否则死循环
            temp = temp.next;
        }
    }
}

3.4、面试题

获取到单链表的节点的个数（无论是否带头结点的单链表，都不进行统计头结点）

在3.3创建单链表中加入获取头结点的方法，并在最后面加入上述面试题方法

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

/**
* 获取到单链表的节点的个数（无论是否带头结点的单链表，都不进行统计头结点）
* @param head 单链表的头结点
* @return 返回单链表有效节点个数
*/
public static int getSingleLinkedLength(HeroNode head) {
    // 定义一个辅助引用
    HeroNode currentNode = head.next;
    // 设置长度
    int length = 0;
    // 遍历链表,只要当前节点不为空
    while (currentNode != null) {
        length++;
        currentNode = currentNode.next;
    }
    return length;
}

获取单链表中倒数第K的节点

/**
* 获取单链表中的倒数第K个节点
* 思路
* 首先 编写一个方法，接收头结点，同时接收一个index【index表示倒数第index个节点】
* 再者 先把链表从头到尾遍历，得到链表的总长度【运用上一题的方法】
* 其次 得到总长度后，我们从单链表的第一个开始遍历（总长度-index）个，就可以进行获取
* 最后 如果找到就返回该节点，否则返回null
*/
public static HeroNode findLastIndexHeroNode(HeroNode head, int index) {
    // 如果单链表为空，返回null
    if (head.next == null) {
        return null;
    }
    // 第一次遍历得到链表的长度（有效节点个数）
    int length = getSingleLinkedLength(head);
    // 第二次遍历 length-index位置，就是我们倒数的第K个节点
    // 判断index的值是否合法
    if (index <= 0 || index > length) {
        return null;
    }
    // 定义临时引用,通过for循环定位到倒数的index
    HeroNode currentHeroNode = head.next;
    for (int i = 0; i < length - index; i++) {
        currentHeroNode = currentHeroNode.next;
    }
    return currentHeroNode;
}

单链表的反转

/**
* 将单链表进行反转
* 思路
* 首先 先定义一个节点reverseHead = new HeroNode()
* 再者 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
* 最后 原来的链表的head.next = reverseHead.next
* @param head 单链表的头结点
*/
public static void reverseList(HeroNode head) {
    // 如果当前链表为空，或者只有一个节点，无需反转，直接返回
    if (head.next == null || head.next.next == null) {
        return;
    }
    // 定义一个辅助引用，帮助我们遍历原来的链表
    HeroNode currentNode = head.next;
    HeroNode nextNode = null; // 指向当前节点【currentNode】的下一个节点
    HeroNode reverseHead = new HeroNode(0, "", "");
    // 遍历原来的单链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
    while (currentNode != null) {
        // 暂时保存当前节点的下一个节点，后面将nextNode赋值给currentNode
        nextNode = currentNode.next;
        // 将currentNode的下一个节点指向新的链表的头部
        currentNode.next = reverseHead.next;
        // 将新的链表reverseHead头结点的next指向currentNode
        reverseHead.next = currentNode;
        // 让currentNode后移
        currentNode = nextNode;
    }
    // 将head.next 指向 reverseHead.next,实现单链表的反转
    head.next = reverseHead.next;
}

逆序打印单链表

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

4、双向链表

4.1、应用场景

• 对线性表的长度或者规模难以估计

• 频繁做插入删除操作

• 构建动态性比较强的线性表

4.2、创建双向链表节点

// 创建双向链表的节点
public class DoubleHeroNode {

    public int no; // 编号
    public String name; // 名称
    public String nickname; // 昵称
    public DoubleHeroNode next; // 指向后一个节点
    public DoubleHeroNode pre; // 指向前一个节点

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

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

4.3、创建双向链表

// 创建一个双向链表
public class DoubleLinkedList {

    // 初始化头结点，头结点不带数据
    private final DoubleHeroNode head = new DoubleHeroNode(0, "", "");

    /**
     * 添加节点到双向链表
     * 当不考虑编号顺序时
     * - 找到当前链表的最后节点
     * - 将最后这个节点的next指向新的节点
     * @param heroNode 要添加的节点
     */
    public void add(DoubleHeroNode heroNode) {
        // 由于头结点【head】不能动，所以我们需要一个辅助引用temp
        DoubleHeroNode temp = head;
        // 遍历链表，找到最后
        while (temp.next != null) {
            // 当遍历到节点的next等于null,则遍历到了最后
            // 如果没有找到最后，就将temp后移
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    /**
     * 当考虑编号顺序时
     * - 首先找到新添加节点的位置，通过辅助引用遍历
     * - 新的节点的next = 辅助引用的next
     * - 将辅助引用的next = 新的节点
     * @param heroNode 要添加的节点
     */
    public void addBySort(DoubleHeroNode heroNode) {
        // 因为头结点不能动，因此我们仍然通过一个辅助引用来帮助我们找到添加的位置
        DoubleHeroNode temp = head;
        // 设置标志添加的编号是否存在，默认为false
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                // 位置找到，就在辅助引用的后面进行插入
                break;
            } else if (temp.next.no == heroNode.no) {
                // 说明想要添加的节点已经存在
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 判断flag标志的值
        if (flag) {
            // 不能添加，编号已经存在
            System.out.printf("待插入的节点编号 %d 已经存在，无法进行插入\n", heroNode.no);
        } else {
            // 为了防止出现空指针的情况，需要对temp节点的位置进行判断
            // 如果双向链表未到达尾部
            if (temp.next != null) {
                // 在辅助引用前插入节点
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
            }
            // 无论有没有到达尾部
            temp.next = heroNode;
            heroNode.pre = temp;
        }
    }

    // 修改节点信息，根据编号修改，及编号不能修改【与单向链表一样，节点的内容发生改变而已】
    public void updateByNo(DoubleHeroNode newHeroNode) {
        // 判断单链表是否为空
        if (head.next == null) {
            System.out.println("单链表为空~");
            return;
        }
        // 根据编号找到要修改的节点
        // 定义一个辅助引用
        DoubleHeroNode 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);
        }
    }

    /**
     * 从单链表中删除一个节点
     * 思路
     * - 我们可以直接找到要删除节点的编号
     * - 找到后进行自我删除即可
     * @param no 要删除节点的编号
     */
    public void del(int no) {
        if (head.next == null) {
            System.out.println("双向链表为空，不能删除");
            return;
        }
        DoubleHeroNode temp = head.next;
        // 标志是否找到了被删除编号的节点
        boolean findFlag = false;
        while (true) {
            // 说明已经遍历到了单链表的最后，没有找到待删除节点
            if (temp == null) {
                break;
            }
            // 如果临时引用的下一个节点的编号等于待删除节点的编号，那么就是找到了待删除节点的前一个节点，即临时引用
            if (temp.no == no) {
                // 设置标志为true
                findFlag = true;
                break;
            }
            temp = temp.next;
        }
        if (findFlag) {
            temp.pre.next = temp.next;
            if (temp.next != null) {
                // 如果要删除的节点是最后一个节点,则不需要执行
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("没有找到待删除编号为 %d 的节点，无法进行删除\n", no);
        }
    }

    // 显示链表【遍历链表】
    public void showSingleLinkedList() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法遍历");
            return;
        }
        // 如果不为空，则创建一个辅助引用temp，因为头结点不能动
        DoubleHeroNode temp = head.next;
        while (temp != null) {
            // 判断是否遍历到了链表的最后
            // 输出节点的信息
            System.out.println(temp);
            // 将temp进行后移，否则死循环
            temp = temp.next;
        }
    }
}

5、单向环形链表【约瑟夫问题】

5.1、应用场景

小孩报数

5.2、创建环形链表节点

// 创建一个环形链表节点
public class CircleNode {

    private int no; // 编号
    private CircleNode next; // 指向下一个节点，默认为null

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

    public int getNo() {
        return no;
    }

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

    public CircleNode getNext() {
        return next;
    }

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

5.3、创建环形单向链表

// 创建一个环形单向链表
public class CircleLinkedList {

    // 创建一个first节点，当前没有编号
    private CircleNode first = new CircleNode(-1);

    // 添加小孩节点，构建成一个环形链表
    public void addCircle(int nums) {
        // nums做一个数据校验
        if (nums < 2) {
            System.out.println("nums的值不正确");
            return;
        }
        // 辅助引用，帮助构建环形链表
        CircleNode currentNode = null;
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            CircleNode node = new CircleNode(i);
            // 如果是第一个节点
            if (i == 1) {
                first = node;
                // 构成环形链表
                first.setNext(first);
                // 让currentNode指向第一个节点
                currentNode = first;
            } else {
                currentNode.setNext(node);
                node.setNext(first);
                currentNode = node;
            }
        }
    }

    // 遍历当前的环形链表
    public void showCircleLinkedList() {
        // 判断链表是否为空
        if (first == null) {
            System.out.println("没有任何节点");
            return;
        }
        // 因为first不能动，因此我们仍然使用一个辅助引用完成遍历
        CircleNode currentNode = first;
        while (true) {
            System.out.printf("节点的编号 %d \n", currentNode.getNo());
            // 说明节点已经遍历完毕
            if (currentNode.getNext() == first) {
                break;
            }
            // currentNode后移
            currentNode = currentNode.getNext();
        }
    }

    /**
     * 根据用户的输入，计算出节点出圈的顺序
     * @param startNo 表示从第几个节点开始数数
     * @param countNum 表示数几下
     * @param nums 表示最初有多少节点在圈内
     */
    public void countNode(int startNo, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建一个辅助引用，帮助完成节点出圈
        CircleNode helper = first;
        // 需求创建一个辅助引用helper，事先应该执行环形链表的最后这个节点
        while (helper.getNext() != first) {
            // 说明helper还没指向最后节点
            helper = helper.getNext();
        }
        // 节点报数时，先让first 和 helper移动startNo-1次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当节点报数时，让first和helper引用同时移动 countNum-1次, 然后出圈
        // 循环到圈中只有一个节点为止
        while (helper != first) {
            // 说明圈中只有一个节点
            // 让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", helper.getNo());
    }
}

6、栈

6.1、应用场景

括号匹配、函数调用、表达式求值、浏览器页面的前进和后退

6.2、创建数组栈

// 定义一个ArrayStack代表数组栈
public class ArrayStack {
    // 定义栈的大小
    private int maxSize;
    // 定义数组,用该数组模拟战，数据放在数组中
    private int[] stack;
    // 表示栈顶，初始化为-1
    private int top = -1;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    // 栈满
    public boolean isStackFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isStackEmpty() {
        return top == -1;
    }

    // 入栈
    public void pushStack(int value) {
        // 判断栈是否已满
        if (isStackFull()) {
            System.out.println("栈已满");
            return;
        }
        top++;
        this.stack[top] = value;
    }

    // 出栈,将栈顶数据进行返回
    public int popStack() {
        // 先判断栈是否为空
        if (isStackEmpty()) {
            // 抛异常
            throw new RuntimeException("栈空，没有数据可返回");
        }
        // 先定义一个临时变量,用来接收将要弹出的数据
        int temp = this.stack[top];
        top--;
        return temp;
    }

    // 显示栈的所有数据【遍历栈，从栈顶开始显示数据】
    public void showStack() {
        if (isStackEmpty()) {
            System.out.println("栈空，没有数据可显示");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, this.stack[i]);
        }
    }
}

6.3、创建链栈

// 创建链栈
public class LinkedStack {

    // 栈顶元素
    private StackNode top;
    // 当前栈的大小
    private int size;

    // 创建空链栈
    public LinkedStack() {
        top = null;
    }

    // 以data数据的节点创建链栈
    public LinkedStack(Object data) {
        top = new StackNode(data, null);
        size++;
    }

    // 判断链栈是否为空栈
    public boolean isLinkedStackEmpty() {
        return size == 0;
    }

    // 将节点压入栈
    public void pushLinkedStack(Object data) {
        top = new StackNode(data, top);
        size++;
    }

    // 将节点出栈
    public Object popLinkedStack() {
        if (isLinkedStackEmpty()) {
            System.out.println("空栈，无法将数据弹出");
            return null;
        }
        StackNode oldTop = top;
        // 更新头结点
        top = top.next;
        // 释放原来栈顶节点的next引用，删除指向
        oldTop.next = null;
        size--;
        return oldTop.data;
    }

    // 获取栈顶元素
    public Object getLinkedStackTop() {
        // 若当前为空栈,则返回null
        if (isLinkedStackEmpty()) {
            return null;
        }
        return top.data;
    }

    // 清空链栈
    public void clean() {
        top = null;
        size = 0;
    }

    // 显示链栈中的所有元素
    @Override
    public String toString() {
        if (isLinkedStackEmpty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (StackNode currentNode = top; currentNode != null; currentNode = currentNode.next) {
                sb.append(currentNode.data.toString()).append(",");
            }
            sb.append("]");
            int length = sb.length();
            return sb.delete(length - 3, length - 1).toString();
        }
    }
}