1. Java 数据结构和算法

java -韩顺平 图解Java 数据结构 和 算法-尚硅谷

一. 数据结构与算法概述

1. 数据结构和算法的关系

1. 数据 data 结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构可以
   编写出更加漂亮,更加有效率的代码。
2. 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决.
3. 程序 = 数据结构 + 算法
4. 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。

2. 线性结构和非线性结构

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

(1). 线性结构

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

(2). 非线性结构

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

二. 稀疏数组和队列

1. 稀疏 sparsearray 数组

(1). 实际需求

• 编写的五子棋程序中，有存盘退出和续上盘的功能。
  

• 分析问题:
  因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据.->稀疏数组

(2). 基本介绍

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是:

1. 记录数组一共有几行几列，有多少个不同的值
2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
   

(3). 应用实例

1. 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组数
3. 整体思路分析
   

(4). 代码实现

package com.wzt.sparsearray;

/**
 * @author WZT
 * @create 2021-07-30 20:47
 */
public class SparseArray {
   
    public static void main(String[] args) {
   
        //创建一个原始的二维数组 11*11
        //0:表示没有棋子，1表示黑子2表蓝子
        int chessArr[][] = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][5] = 2;
        //输出原始的二维数组
        System.out.println("原始的二维数组~~");
        for (int[] row : chessArr) {
   
            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 (chessArr[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 (chessArr[i][j] != 0) {
   
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr[i][j];
                }
            }
        }

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

        // 将稀疏数组 恢复成 原始的二维数组

        // 1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组

        int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];

        // 2.读取稀疏数组后几行的数据（从第二行开始），并赋给 原始的二维数组 即可

        for (int i = 1; i < sparseArr.length; i++) {
   
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] =  sparseArr[i][2];
        }

        // 输出恢复后的二维数组
        System.out.println();
        System.out.println("输出恢复后的二维数组");

        for (int[] row : chessArr2) {
   
            for (int data: row) {
   
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}

输出:

原始的二维数组~~
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	2	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

得到的稀疏数组为~~~~~
11	11	3	
1	2	1	
2	3	2	
4	5	2	


输出恢复后的二维数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	2	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

2. 队列

(1). 队列的一个使用场景

银行排队的案例:

(2). 队列介绍

1. 队列是一个有序列表，可以用数组或是链表来实现。
2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
3. 示意图：(使用数组模拟队列示意图)
   

(3). 数组模拟队列思路

• 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中maxSize是该队
  列的最大容量。
• 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及`` rear分别记录队列前后端的下标，
  front会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示:
  
  当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
• 1. 将尾指针往后移：rear+1 , 当 front == rear 【空】
• 2. 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。
     rear == maxSize - 1[队列满]

(4). 代码实现

 package com.wzt.queue;

import java.util.Scanner;

/**
 * @author WZT
 * @create 2021-07-31 8:54
 */
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 'a':
                    System.out.println("输出一个数字");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
   
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
   
                        //处理异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
   
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
   
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出!");
    }

}

class ArrayQueue {
   
    private int maxSize;// 表示数组的最大容量
    private int front;// 队列头
    private int rear;// 队列尾
    private int[] arr;// 该数组用于存放数据,模拟队列

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

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

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

    // 添加数据队列
    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++;// 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];
    }
}

3. 数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)

(1). 分析说明：

• 1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front 满]
• 2. rear == front [空]
• 3. 分析示意图:
     

(2). 代码实现

package com.wzt.queue;

import java.util.Scanner;

/**
 * @author WZT
 * @create 2021-07-31 14:02
 */
public class CircleArrayQueueDemo {
   
    public static void main(String[] args) {
   
        //测试一把
        System.out.println("测试数组模拟环形队列的案例~~~");
        // 创建一个环形队列
        CircleArray queue = new CircleArray(4);// 说明设置 4 ,其队列的有效数据最大是 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 'a':
                    System.out.println("输出一个数字");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
   
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
   
                        //处理异常
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
   
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
   
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    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) {
   
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }

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

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

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

    // 获取队列的数据, 出队列
    public int getQueue() {
   
        if (isEmpty()) {
   
            throw new RuntimeException("队列空,不能取数据");
        }
        // 这里需要分析 front , 不能直接 return arr[front] ,需要先赋值给一个临时值,然后将 front + 1
        // front + 1 表示头部向后移动一位,为之后可以再次添加数据做准备!!!!
        int tmp = arr[front];
        front = (front + 1)%maxSize;
        return tmp;
    }

    //显示队列的所有数据
    public void showQueue() {
   
        // 遍历
        if (isEmpty()) {
   
            System.out.println("队列空,不能取数据");
        }
        // 思路: 从 front 开始遍历, 遍历多少个元素
        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];
    }

}

三. 链表

1. 链表(Linked List)介绍

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

小结上图:

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

单链表(带头结点) 逻辑结构示意图如下

2. 单链表的应用实例(含面试题)

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

1. 第一种方法在添加英雄时，直接添加到链表的尾部
   思路分析示意图:
   
2. 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)
   思路的分析示意图
   
3. 修改节点功能
   思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname
4. 删除节点
   思路分析的示意图
   

package com.wzt.linkedlist;

import javax.xml.transform.Source;
import java.util.Stack;

/**
 * @author WZT
 * @create 2021-07-31 15:45
 */
public class SingleLinkedListDemo {
   
    public static void main(String[] args) {
   
        //进行测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero5 = new HeroNode(2, "小卢", "小玉");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        //创建链表
        SingleLinkedlist singleLinkedlist = new SingleLinkedlist();
        //插入节点
        singleLinkedlist.add(hero1);
        singleLinkedlist.add(hero4);
        singleLinkedlist.add(hero2);
        singleLinkedlist.add(hero3);

        singleLinkedlist.list();

        System.out.println("筛选:" + findLastIndexNode(singleLinkedlist.getHead(), 1));
        reverseList(singleLinkedlist.getHead());
        System.out.println("反转后打印");
        singleLinkedlist.list();
        System.out.println("反转着打印,链表实际上没有反转");
        reversePrint(singleLinkedlist.getHead());

/*        //插入节点
        singleLinkedlist.addByOrder(hero1);
        singleLinkedlist.addByOrder(hero4);
        singleLinkedlist.addByOrder(hero2);
        singleLinkedlist.addByOrder(hero3);
        System.out.println("修改链表之前");
        singleLinkedlist.list();
        singleLinkedlist.update(hero5);
        System.out.println("修改链表之后");
        singleLinkedlist.list();
        singleLinkedlist.del(1);
        //singleLinkedlist.del(2);
        //singleLinkedlist.del(3);
        singleLinkedlist.del(4);
        System.out.println("删除链表元素后");
        singleLinkedlist.list();
        System.out.println("链表中的所有元素有" + getLength(singleLinkedlist.getHead()) + "个");*/
    }

    // 面试题:
    // 获取到单链表的节点的个数 (如果是带头节点的链表, 需求不统计头结点)
    /**
     *
     * @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;
    }

    //查找单链表中的倒数第 k 个节点
    //思路:
    //1. 编写一个方法, 接收 head 节点, 同时接收一个 index
    //2. index 表示倒数第 index 个节点
    //3. 先把链表从头到尾遍历, 得到链表的总长度为 getLength
    //4. 得到 size 后, 我们从链表的第一个开始遍历 (size - index)个, 就可以得到
    //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;
    }

    //将单链表反转
    public static void reverseList(HeroNode head) {
   
        //如果当前链表为空, 或者只有一个节点, 则无需反转
        if (head.next == null || head.next.next == null) {
   
            return;
        }

        //定义一个辅助的指针(变量), 帮助我们遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;// 指向当前节点[cur] 的下一个节点
        HeroNode reverseHead = new HeroNode(0, "", "");
        //遍历原来的链表, 每遍历一个节点, 就将其取出, 并放在新链表的最前端
        while (cur != null) {
   
            next = cur.next;//先保存下一个节点, 因为后面需要使用
            cur.next = reverseHead.next;//将 cur 的下一个节点指向新的链表的最前端
            reverseHead.next = cur;//将 cur 连接到新的链表上
            cur = next;//让 cur 后移
        }
        //将 head.next 指向 reverseHead.next, 实现单链表的反转
        head.next = reverseHead.next;
    }

    //单链表的逆序打印
    //可以利用栈的数据结构, 将各个节点压入到栈中, 然后利用栈的先进后出的特点, 就实现了逆序打印的效果
    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;//cur 后移, 这样就可以压入下一个节点
        }
        //将栈中的节点进行打印, pop 出栈
        while (stack.size() > 0) {
   
            System.out.println(stack.pop());//stack 的特点是先进后出
        }
    }
}

//定义 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) {
   
        // 因为头结点不能动, 因此我们仍然通过一个辅助指针(变量) 来帮助找到添加的位置
        // 因为单链表, 因此我们找的 temp 是位于 添加位置前的一个节点, 否则插入不了
        HeroNode temp = head;
        boolean flag = false;// 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 编号来修改, 即 no 编号不能改
    //1. 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode) {
   
        //判断是否为空
        if (head.next == null) {
   
            System.out.println("链表为空~~");
            return;
        }
        //找到需要修改的节点, 根据 no 编号
        //定义一个辅助变量
        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);
        }
    }

    //删除节点
    //思路
    //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;//temp 后移, 遍历
        }
        //判断 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的 toString 方法()
            //toString 方法在遇到 print 的方法时会自动调用
            //将 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 + '\'' +
                '}';
    }
}

输出

HeroNode{
   no=1, name='宋江', nickname='及时雨'}
HeroNode{
   no=4, name='林冲', nickname='豹子头'}
HeroNode{
   no=2, name='卢俊义', nickname='玉麒麟'}
HeroNode{
   no=3, name='吴用', nickname='智多星'}
筛选:HeroNode{
   no=3, name='吴用', nickname='智多星'}
反转后打印
HeroNode{
   no=3, name='吴用', nickname='智多星'}
HeroNode{
   no=2, name='卢俊义', nickname='玉麒麟'}
HeroNode{
   no=4, name='林冲', nickname='豹子头'}
HeroNode{
   no=1, name='宋江', nickname='及时雨'}
反转着打印,链表实际上没有反转
HeroNode{
   no=1, name='宋江', nickname='及时雨'}
HeroNode{
   no=4, name='林冲', nickname='豹子头'}
HeroNode{
   no=2, name='卢俊义', nickname='玉麒麟'}
HeroNode{
   no=3, name='吴用', nickname='智多星'}

3. 双向链表应用实例

(1). 双向链表的操作分析和实现

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

• 管理单向链表的缺点分析:

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2. 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到 temp,temp 是待删除节点的前一个节点(认真体会).
3. 分析了双向链表如何完成遍历，添加，修改和删除的思路
   
   对上图的说明:
   分析 双向链表的遍历，添加，修改，删除的操作思路===》代码实现
4. 遍历 方和 单链表一样，只是可以向前，也可以向后查找
5. 添加 (默认添加到双向链表的最后)
   (1) 先找到双向链表的最后这个节点
   (2) temp.next = newHeroNode
   (3) newHeroNode.pre = temp;
6. 修改 思路和 原来的单向链表一样.
7. 删除
   (1) 因为是双向链表，因此，我们可以实现自我删除某个节点
   (2) 直接找到要删除的这个节点，比如 temp
   (3) temp.pre.next = temp.next
   (4) temp.next.pre = temp.pre

4. 代码实现

package com.wzt.linkedlist;

/**
 * @author WZT
 * @create 2021-08-02 9:06
 */
public class DoubleLinkedListDemo {
   
    public static void main(String[] args) {
   
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 hero4 = new HeroNode2(4,"林冲","豹子头");
        HeroNode2 hero5 = new HeroNode2(6, "小卢", "小玉");
        DoubleLinkedList list = new DoubleLinkedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);
        list.update(hero5);
        list.delete(4);
        list.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){
   

        //临时变量代替头结点
        HeroNode2 temp = head;

        while (true) {
   
            //找到链表的最后一个位置, 进行添加
            if (temp.next == null) {
   
                temp.next = heroNode;
                heroNode.pre = temp;
                break;
            } else {
   
                temp = temp.next;
            }
        }

    }

    //修改一个节点信息
    public void update(HeroNode2 heroNode) {
   
        if (head.next == null) {
   
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true) {
   
            if (temp == null) {
   
                break;//已经遍历完毕没有找到
            }
            if (temp.no == heroNode.no) {
   //已经找到未修改的节点
                flag = true;
                break;
            } else {
   
                temp = temp.next;//将 temp 向后移动
            }
        }

        if (flag) {
   
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        } else {
   
            System.out.println("没有找到编号为: " + heroNode.no + " 的节点, 不能修改");
        }
    }

    //删除一个节点
    public void delete(int n) {
   
        //判断链表是否为空
        if (head.next == null) {
   
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;//标志是否找到要删除的节点
        while (true) {
   
            if (temp == null) {
   
                break;//链表到最后了
            }
            if (temp.no == n) {
   
                flag = true;
                break;
            } else {
   
                temp = temp.next;
            }
        }

        if (flag) {
   
            temp.pre.next = temp.next;
            if (temp.next != null) {
   
                temp.next.pre = temp.pre;
            }
        } else {
   
            System.out.println("未能找到需要删除的节点 " + n);
        }
    }

}
//定义 HeroNode2 ,每个 Node 对象 就是一个节点
class HeroNode2 {
   
    public int no;
    public String name;
    public String nickName;
    public HeroNode2 next;// 指向下一个节点, 默认为 null
    public HeroNode2 pre;// 指向前一个节点, 默认为 null

    //构造器
    public HeroNode2() {
   
    }

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

    //toString

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

输出:

没有找到编号为: 6 的节点, 不能修改
HeroNode2{
   no=1, name='宋江', nickName='及时雨'}
HeroNode2{
   no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode2{
   no=3, name='吴用', nickName='智多星'}

5. 单向环形链表

(1). 应用场景

Josephu(约瑟夫、约瑟夫环) 问题
Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
提示：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

(2). 介绍

(3). Josephu 问题

1. 约瑟夫问题的示意图
   

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

3. 提示
   用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束.

约瑟夫问题-创建环形链表的思路图解

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

(4). Josephu 问题的代码实现

package com.wzt.linkedlist;

/**
 * @author WZT
 * @create 2021-08-02 20:57
 */
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 = 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;
            } 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();//curBoy 后移
        }
    }

    //根据用户的输入, 计算出小孩出圈的顺序

    /**
     *
     * @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;
        //需求创建一个辅助指针(/), 事先应该指向环形链表的最后这个节点
        while (true) {
   
            if (helper.getNext() == first) {
   //说明helper指向小孩的最后节点
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前, 让 first 和 helper 指针同时的移动 countNum - 1
        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.println("小孩" + first.getNo() + "出圈");
            //此时将 first 指针指向小孩节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.println("最后留在圈中的小孩编号 " + 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;
    }
}

输出:

小孩的编号 1
小孩的编号 2
小孩的编号 3
小孩的编号 4
小孩的编号 5
小孩2出圈
小孩4出圈
小孩1出圈
小孩5出圈
最后留在圈中的小孩编号 3

四. 栈

1. 栈的介绍

1. 栈的英文为(stack)
2. 栈是一个先入后出(FILO-First In Last Out)的有序列表。
3. 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
4. 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
5. 图解方式说明出栈(pop)和入栈(push)的概念
   

2. 栈的应用场景

1. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4. 二叉树的遍历。
5. 图形的深度优先(depth 一 first)搜索法。

3. 栈的快速入门

1. 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作。
2. 实现思路分析,并画出示意图
   

4. 代码实现(数组实现栈)

package com.wzt.stack;

import java.util.Scanner;

/**
 * @author WZT
 * @create 2021-08-03 9:21
 */
public class ArrayStackDemo {
   
    public static void main(String[] args) {
   
        //测试一下 ArrayStack 是否正确
        //先创建一个 ArrayStack 对象 -> 表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true; //控制是否退出菜单
        Scanner scanner = new Scanner(System.in);

        while (loop) {
   
            System.out.println("show: 表示显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push: 表示添加数据到栈(入栈)");
            System.out.println("pop: 表示从栈取出数据(出栈)");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
   
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数字");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
   
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);
                    } catch (Exception e) {
   
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~~");
    }
}

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

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

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

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

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

    //出栈 -pop, 将栈顶的数据返回
    public int pop() {
   
        //先判断栈是否为空
        if (isEmpty()) {
   
            //抛出异常
            throw new RuntimeException("栈空, 没有数据~");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //显示栈的情况[遍历栈], 遍历时, 需要从栈顶开始显示数据
    public void list() {
   
        if (isEmpty()) {
   
            System.out.println("栈空, 没有数据~~~");
            return;
        }
        //需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
   
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}

5. 代码实现(链表实现栈)

package com.wzt.stack;

/**
 * @author WZT
 * @create 2021-08-03 22:30
 * 代码参考:https://blog.csdn.net/ljxbbss/article/details/78127036
 */
public class LinkedListStackDemo {
   
    public static void main(String[] args) {
   
        LinkedListStack stack = new LinkedListStack();

        stack.push("栈帧1");
        stack.push("栈帧2");
        stack.push("栈帧3");
        stack.push("栈帧4");
        stack.list();
        System.out.println("栈顶抛出了:" + stack.pop());
        stack.list();
        System.out.println("目前栈顶是:" + stack.peek());


    }
}

//创建 node 节点
class Node {
   
    public Node next;
    public Object element;

    public Node(Node next, Object element) {
   
        this.next = next;
        this.element = element;
    }


    @Override
    public String toString() {
   
        return "Node{" +
                "element=" + element +
                '}';
    }
}

//创建一个链表
class LinkedListStack {
   

    int count;//当前栈内元素个数
    Node top;//栈顶指针
    int size;//栈大小

    //初始化一个空栈
    LinkedListStack() {
   
        top = null;
        count = 0;
        this.size = 10;
    }

    //构造一个指定大小的空栈
    LinkedListStack(int size) {
   
        top = null;
        count = 0;
        this.size = size;
    }

    /**
     * 采用这种方法代表每插入一个元素, 新的变成栈顶元素, 同时每次都是链表的头结点
     * @param element
     * @return
     */
    public boolean push(Object element) {
   

        if (isFull()) {
   
            return false;
        }

        // 1. 将插入前的栈顶元素变成新插入节点的 next 指针指向元素
        // 2. 新插入元素变成栈顶节点
        top = new Node(top, element);

        count++;

        return false;
    }

    //抛出元素 pop
    public Object pop() {
   
        if (isEmpty()) {
   
            System.out.println("栈为空")