数据结构详解

数据结构

线性结构

1.最常用的数据结构，特点是数据元素之间存在一对一的线性关系

2.有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表）

3.顺序存储的线性表称为顺序表，顺序表中的元素是连续的

4.链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息

5.线性结构常见的有：数组，队列，链表，栈

非线性结构

二维数组

多维数组

广义表

树结构

图结构

稀疏sparsearray数组

基本介绍

当一个数组大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组

稀疏数组的处理方法是：

1.记录数组一共有几行几列，有多少个不同的值

2.把具有不通知的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

二维数组转稀疏数组的思路：

1.遍历原始的二维数组，得到有效数据的个数sum

2.根据sum就可以创建稀疏数组sparsearray int[sum + 1 , 3]

3.将二维数组的有效数据存到稀疏数组

稀疏数组转二维数组的思路：

1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的数组为Arr1 = int [6] [7]

2.之后读取稀疏数组后几行的数据，并赋给原始的二维数组即可

代码实现

package com.ren.sparsearray;

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.print(data + "\t");
            }
            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++;
                }
            }
        }
        System.out.println("sum = " + 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; //用于记录是低级的非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();
        System.out.println("得到的稀疏数组为:");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
            System.out.println();
        }

        //3.稀疏数组 ==》二维数组
        /**
         * 1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的数组为Arr1 = int [6] [7]
         * 2.之后读取稀疏数组后几行(从第二行开始)的数据，并赋给原始的二维数组即可
         * */
        int chessArray2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
            chessArray2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

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


    }
}

队列Queue

1.是一个有序列表，可以用数组或链表来实现

2.遵循先进先出原则

使用数组的结构来存储队列的数据

1.maxSize 表示队列的最大容量

2.队列的输入，输出分别从队列的头尾进行处理，两个变量front(表示队列头部)和rear(表示队列尾部)

3.将尾指针往后移：rear + 1，当front == rear：队列为空

4.若尾指针rear小于队列的最大下标maxSize - 1，则将数据存入rear所指的数组元素中，否则无法存入数据。

5.rear == maxSize - 1： 队列满

public class ArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个队列
        ArrayQueue arrayQueue = 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':
                    arrayQueue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g'://取出数据
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                    try {
                        int res = arrayQueue.headQueue();
                        System.out.printf("队列头的数据是%d\n",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 arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1;//指向队列头部，分析出front是指向队列头的前一个位置
        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++;//front后移
        return arr[front];
    }

    //显示队列的所有数据
    public void showQueue() {
        //遍历
        if (isEmpty()) {
            System.out.println("队列是空的，没有数据");
        }
        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.front变量的含义做一个调整，front指向队列的第一个元素，也就是arr[front]是队列的第一个元素,front初始值=0

2.rear变量的含义做一个调整，rear指向队列的最后一个元素的后一个位置，希望空出一个空间作为约定，rear初始值=0

3.当队列满时，条件：(rear+1)%maxSize = front

4.当队列为空时，rear = front

5.队列中有效的数据：（rear + maxSize - front）% maxSize

package com.ren.queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        //创建一个环形队列
        CircleArray arrayQueue = 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':
                    arrayQueue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g'://取出数据
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                    try {
                        int res = arrayQueue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

class CircleArray {
    private int maxSize;//表示数组的最大容量
    private int front;//front变量的含义做一个调整，front指向队列的第一个元素，也就是arr[front]是队列的第一个元素,front初始值=0
    private int rear;//rear变量的含义做一个调整，rear指向队列的最后一个元素的后一个位置，希望空出一个空间作为约定，rear初始值=0
    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 rear == front;
    }

    //添加数据到队列
    public void addQueue(int n) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列已满，不能添加数据");
            return;
        }
        //直接将数据加入
        arr[rear] = n;
        //将rear后移,这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }

    //获取队列的数据，出队列
    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("队列是空的，没有数据");
        }
        //思路：从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.链表是以结点的方式来存储

2.每个节点包括data域，next域，指向下一个节点

3.链表的每个节点不一定是连续存储的

4.链表分带头结点的链表和没有头节点的链表

结点定义

//定义一个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 + '\'' +
                '}';
    }
    
//

链表定义

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

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

遍历链表

//显示链表:遍历
    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;
        }
    }

添加结点：不考虑编号

//添加节点到单向链表
    //思路：当不考虑编号顺序时
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode) {

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

添加结点：考虑编号

 //第二种方式在添加节点时，根据排名将节点插入到指定位置
    //(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
        //因为头结点不能动，因此我们仍然通过一个辅助变量来帮助我们找到添加的位置
        //因为单链表，我们找的temp是位于添加位置的前一个结点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//说明temp已经在链表的最后
                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);
        }
    }

新浪面试题：查找单链表中的倒数第k个节点

//查找单链表中的倒数第k个节点【新浪面试题】
    //思路
    //1.编写一个方法，接受head节点，同时接受一个index
    //2.index表示的是倒数第index个节点
    //3。先把链表从头到尾遍历，得到链表的总的长度
    //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;//3 //3-1 =2
        for (int i = 0; i < size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    //方法：获取到单链表的结点的个数（如果是带头结点的链表，需求不统计头结点）

    /**
     * @param head 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;
    }

腾讯面试题：单链表的反转

 //单链表的反转【腾讯面试题】
    //思路
    //1.先定义一个节点reverseHead = new HeroNode();
    //2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表的最前端
    //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 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 class TestStack {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        //入栈
        stack.add("jack");
        stack.add("tom");
        stack.add("smith");
        //出栈
        while(stack.size()>0){
            System.out.println(stack.pop());//pop就是将栈顶的元素取出
        }
    }
    
//百度面试题：从尾到头打印单链表
//思路
//1.就是逆序打印单链表
//2.方式1：先将单链表进行反转操作，然后在遍历即可，这样做的问题是会破坏原来单链表的结构，不建议
//3.方式2：可以利用栈这个数据结构，将各个结点压入栈中，然后利用先进后出的特点，就实现了逆序打印的效果
//使用方式2
public static void reversePrint(HeroNode head){
    if (head.next == null){
        return;//空链表，不能打印
    }
    //创建一个栈，将各个节点压入栈
    Stack<HeroNode> stack = new Stack<HeroNode>();
    HeroNode cur = head.next;
    //将链表的所有结点压入栈
    while (cur != null){
        stack.push(cur);
        cur = cur.next;//cur后移，这样就可以压入下一个节点
    }
    //将栈中的结点进行打印，pop出栈
    while(stack.size()>0){
        System.out.println(stack.pop());
    }
}

测试类

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

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        System.out.println("原来链表的情况：");
        singleLinkedList.list();
    
		//测试逆序打印单链表
        System.out.println("逆序打印单链表的情况");
        reversePrint(singleLinkedList.getHead());
    
        //测试单链表的反转功能
        System.out.println("反转单链表：");
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list();

        //加入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);

        //显示链表
        singleLinkedList.list();

        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟");
        singleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况");

        singleLinkedList.list();
        //删除一个节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);
        System.out.println("删除之后的结果");
        singleLinkedList.list();

        //测试有效节点的个数
        System.out.println("有效节点的个数是"+getLength((singleLinkedList.getHead())));

        //测试得到倒数第k个节点
        HeroNode res = findLastIndexNode(singleLinkedList.getHead(),2);
        System.out.println("res ="+res);

    }

双向链表

数据

next

pre

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

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

2.单向链表不能自我删除，需要依靠辅助结点，而双向链表可以实现自我删除。前面我们单链表删除结点时，总是能找见temp，temp是待删除结点的前一个结点

3.双向链表的遍历，添加，修改，删除

遍历

遍历的方式和单链表一样，只是可以向前，也可以向后查找

//遍历双向链表的方法
    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;
        }
    }

添加

默认添加到双向链表的最后

1.通过遍历找到双向链表的最后

2.temp.next = newHeroNode

3.newHeroNode.pre = temp

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

按照编号添加

//第二种方式在添加节点时，根据排名将节点插入到指定位置
//(如果有这个排名，则添加失败，并给出提示)
public void addByOrder(HeroNode2 heroNode) {
    //因为头结点不能动，因此我们仍然通过一个辅助变量来帮助我们找到添加的位置
    //因为单链表，我们找的temp是位于添加位置的前一个结点，否则插入不了
    HeroNode2 temp = head;
    boolean flag = false;//flag标志添加的编号是否存在，默认为false
    while (true) {
        if (temp.next == null) {//说明temp已经在链表的最后
            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;
    }
}

修改

修改的思路和单向链表一样

//修改一个结点的内容，和单向链表的修改一样
    public void update(HeroNode2 newHeroNode) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        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);
        }
    }

删除

1.因为是双向链表，因此我们可以实现自我删除某个节点

2.直接找到要删除的这个节点，比如temp

3.temp.pre.next = temp.next

4.temp.next.pre = temp.pre

//从双向链表中删除一个结点
    //对于双向链表我们可以直接找到要删除的这个节点，找到后删除即可
    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) {
                //找到的待删除结点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;//temp后移，遍历
        }
        //判断flag
        if (flag) {//找到
            //可以删除
            //temp.next = temp.next.next;//单向链表的删除方法
            temp.pre.next = temp.next;
            //如果是最后一个节点，就不需要执行下面这句，否则出现空指针
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }


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

环形链表

约瑟夫问题：

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

提示：

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

创建环形结点

//创建一个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.构建一个单向环形链表，让first指向该节点，并形成环形

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

//创建一个环形的单向链表
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;
            }
        }
    }

遍历环形链表

1.先让一个辅助变量指向first结点

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

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

实现约瑟夫问题

根据用户输入，生成一个小孩出圈的顺序

1.需要创建一个辅助变量，事先应该指向环形链表的最后结点

2.当小孩报数时，让first和helper指针同时的移动m-1次

3.这时可以将first指向的小孩结点出圈

first = first.next

helper.next = first

原来first指向的结点就没有任何引用，就会被回收

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

/**
 * @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次，移动到第一次报数的位置
    for (int j = 0; j < startNo - 1; j++) {
        first = first.getNext();
        helper = helper.getNext();
    }
    //当小孩报数前，让first和helper指针同时移动m-1次,移动到然后出圈
    //这里是一个循环的操作
    while (true) {
        if (helper == first) {//说明圈中只有一个结点
            break;
        }
        //让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());
}

栈(stack)

1.栈是一个先入后出的有序列表

2.栈时限制线性列表中元素的插入和删除只能在线性表的同一段进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶，另一端为固定的一端，称为栈底。

3.根据栈的定义可知，最先放入栈中的元素在栈底（Bottom），最后放入的元素在栈顶（Top），而删除元素刚好相反，最后放入的元素最先删除，最先放入的的元素最后删除

4.出栈：pop 入栈：push

应用场景：子程序的调用，处理递归调用，表达式的转换（中缀表达式转后缀表达式），二叉树的遍历，图形的深度优先搜索法

实现栈的思路分析

使用数组来模拟栈

1.使用数组来模拟栈

2.定义一个top来表示栈顶，初始化为-1

3.入栈的操作，当有数据加入时，top++;stack[top]=data;

4.出栈的操作，int value = stack[top], return value

package com.ren.stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        //先创建一个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]);
        }
    }
}

使用栈计算表达式

思路

1.通过一个index值（索引），来遍历我们的表达式

2.如果我们发现是一个数字，就直接入数栈

3.如果是一个符号，分以下情况

​ 3.1如果发现当前的符号栈为空，就直接入栈

​ 3.2如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop两个数，再从符号栈中pop一个符号，进行运算，将得到结果入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈

4.当表达式扫描完毕之后，就顺序的从数栈和符号栈中pop出相应的书和符号，并运行

5.最后在数栈只有一个数字，就是表达式的结果

package com.ren.stack;

public class Calculator {
    public static void main(String[] args) {
        String expression = "30+2*6-20/10";
        //创建两个栈，数栈，符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义需要的变量
        int index = 0;//用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';//将每次扫描得到char保存到ch
        String keepNum = "";//用于拼接多位数
        //开始while循环的扫描expression
        while (true) {
            //依次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //判断ch的类型
            if (operStack.isOper(ch)) {//如果是运算符
                //判断当前符号栈是否为空
                if (!operStack.isEmpty()) {
                    //如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数
                    //再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，然后将当前的操作符如符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.pick())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //把运算的结果入数栈
                        numStack.push(res);
                        //然后将当前的操作符入符号栈
                        operStack.push(ch);
                    } else {
                        //如果当前的操作符大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    //如果为空直接写入符号栈
                    operStack.push(ch);
                }
            } else {
                //如果是数，则直接入数栈
                //numStack.push(ch - 48);
                //分析思路
                //1.当处理多位数时，不能发现是一个数就立即入栈，可能是多位数
                //2.在处理数时，需要向expression的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个变量字符串，用于拼接
                //处理多位数
                keepNum += ch;
                //如果ch已经是expression的最后一位，则直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                    //判断下一个字符是不是数字，如果是数字，则继续扫描，入时运算符，则入栈
                    //注意：是看后面一位
                    //如果后一位是运算符，则入栈
                    numStack.push(Integer.parseInt(keepNum));
                    //重要：keepNum清空
                    keepNum = "";
                }

            }
            //让index+1，并判断是否扫描到experssion最后
            index++;
            if (index >= expression.length()) {
                break;
            }
        }
        //当表达式扫描完毕之后，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);//入栈
        }
        //将数栈的最后数pop出来就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式%s = %d", expression, res2);
    }
}

//先创建一个栈，直接使用前面创建好的
//定义一个ArrayStack表示栈
class ArrayStack2 {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈，数据就放在该数组
    private int top = -1;//top表示栈顶，初始化-1

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

    //返回当前栈顶的值，但不是真正的pop
    public int pick() {
        return stack[top];
    }

    //栈满
    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]);
        }
    }

    //返回运算符的优先级，程序员来确定的
    //数字越大，则优先级越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;//目前的运算符只有加减乘除
        }
    }

    //判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法
    public int cal(int num1, int num2, int oper) {
        int res = 0;//res用于存放计算结果
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

逆波兰表达式

逆波兰计算器

1.输入一个逆波兰表达式（后缀表达式），使用栈，计算器结果

2.支持小括号和多位整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算

3.思路：

1.先将"3 4 + 5 * 6 - "放到ArrayList中

2.将ArrayList 传递给一个方法，配合栈完成计算

package com.ren.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {
        //先定义一个逆波兰表达式
        //(3+4)*5-6  =>  3 4 + 5 * 6 -
        //说明为了方便，逆波兰表达式的数字和符号用空格隔开
        String suffixExpression = "30 4 + 50 * 6 - ";
        //思路
        //1.先将"3 4 + 5 * 6 - "放到ArrayList中
        //2.将ArrayList 传递给一个方法，配合栈完成计算
        List<String> rpnList = getListString(suffixExpression);
        System.out.println("rpnList = " + rpnList);

        int res = calculate(rpnList);
        System.out.println("计算的结果是"+res);
    }

    //将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
    public static List<String> getListString(String suffixExpression) {
        //将suffixExpression 分割
        String[] split = suffixExpression.split(" ");
        ArrayList<String> list = new ArrayList<>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    //完成对逆波兰表达式的计算
    public static int calculate(List<String> ls) {
        //创建给栈，只需要一个栈即可
        Stack<String> stack = new Stack<String>();
        //遍历ls
        for (String item : ls) {
            //这里使用正则表达式来取数
            if (item.matches("\\d+")) {//匹配的是多位数
                //入栈
                stack.push(item);
            } else {
                //pop出两个数并运算，在入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    return num1 - num2;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //把res入栈
                stack.push(res + "");
            }
        }
        //最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }
}

中缀表达式转后缀表达式

思路分析：

1.初始化两个栈：运算符栈s1和存储中间结果的栈s2

2.从左至右扫描中缀表达式

3.遇到操作数时，将其压入s2

4.遇到运算符时，比较其于s1栈运算符的优先级：

4.1如果s1为空，或栈顶运算符为左括号“（”，则直接将此运算符入栈

4.2否则，若优先级比栈顶元素的高，也将运算符压入s1

4.3否则，将s1栈顶的运算符弹出并压入到s2中，再次转到（4-1）与s1中新的栈顶元素运算符相比较

5.遇到括号时：

5.1如果是左括号“（”，则直接压入s1

5.2如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃

6.重复步骤2-5，直到表达式的最右边

7.将s1中剩余的运算符一次弹出并压入s2

8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

中缀表达式1+((2+3)*4)-5 转后缀表达式：

扫描到的元素	s2(栈底–>栈顶)	符号栈s1(栈底–>栈顶)	说明
1	1	空	数字直接入栈
+	1	+	s1为空，运算符直接入栈
(	1	+(	左括号直接入栈
(	1	+((	左括号直接入栈
2	12	+((	数字直接入栈
+	12	+((+	s1栈顶为左括号，运算符直接入栈
3	123	+((+	数字直接入栈
)	123+	+(	右括号，依次弹出运算符并压入s2直至遇到左括号
*	123+	+(*	s1栈顶为左括号，运算符直接入栈
4	123+4	+(*	数字直接入栈
)	123+4*	+	右括号，依次弹出运算符并压入s2直至遇到左括号
-	123+4*+	-	-与+优先级相同，因此弹出+压入s2，- 压入s1
5	123+4*+5	-	数字直接入栈
到达最右端	123+4*+5-	空	s1中剩余的运算符依次弹出并压入s2

最后将s2出栈，得到结果- 5 + * 4 +3 2 1 ==》逆序 1 2 3 + 4 *+ 5 -

package com.ren.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation1 {
    public static void main(String[] args) {
        //完成将一个中缀表达式转===》后缀表达式
        //说明
        //1.中缀表达式1+((2+3)*4)-5 转后缀表达式 123+4*+5-
        //2.因为直接对str进行操作，不方便，因此先将"1+((2+3)*4)-5 "==》中缀表达式转换对应的List
        //即 "1+((2+3)*4)-5" ==> ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        String expression = "1+((22+3)*4)-5";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List"+infixExpressionList);
        //将得到的中缀表达式对应的List ==》后缀表达式对应的List
        //即ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]==》ArrayList[1,2,3,+,4,*,+,5,-]
        List<String> parseSuffixExpressionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的List"+parseSuffixExpressionList);


    }

    //ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]==》ArrayList[1,2,3,+,4,*,+,5,-]
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<>();//符号栈
        //说明：因为s2这个栈，在整个转换过程中没有弹出操作，而且最后还需要逆序输出
        //因此比较麻烦，这里我们不用Stack,直接使用List  s2
        ArrayList<String> s2 = new ArrayList<>();
        //遍历ls
        for (String item : ls) {
            //如果是一个数，加入s2
            if (item.matches("\\d+")) {//匹配的是多位数
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                //如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//将（ 弹出s1栈，消除左括号
            } else {
                //当item优先级小于等于栈顶运算符，将s1栈顶的运算符弹出并加入到s2中，再次转到（4-1）与s1中新的栈顶元素运算符相比较
                //我们缺少一个运算符优先级的方法
                while (s1.size() != 0 && Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);
            }
        }
        //将s1中剩余的运算符一次弹出并压入s2
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2;//注意因为是存放到List，因此按顺序输出就是对应的后缀表达式对应的List
    }

    //将中缀表达式转成对应的List
    //s = "1+((2+3)*4)-5"
    public static List<String> toInfixExpressionList(String s) {
        //定义一个List,存放中缀表达式对应的内容
        ArrayList<String> ls = new ArrayList<>();
        int i = 0;//这是一个指针,用于遍历中缀表达式字符串
        String str;//对应多位数的拼接
        char c;//每遍历一个字符，就放入到c
        do {
            //如果c是一个非数字，就需要加入到ls中
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++;
            } else {//如果是一个数，需要考虑多位数的问题
                str = "";//先将str置成""
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                ls.add(str);
            }
        } while (i < s.length());
        return ls;
    }

}

//编写一个类Operation，可以返回一个运算符对应的优先级
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //写一个方法，返回对应的优先级数字
    public static int getValue(String opertion) {
        int result = 0;
        switch (opertion) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("该运算符不存在");
                break;
        }
        return result;
    }
}

递归(Recursion)

递归就是方法自己调用自己，每次调用时传入不同的变量

递归调用规则：

1.当程序执行一个方法时，就会开辟一个独立的空间（栈）

2.每个空间的数据（局部变量），是独立的

3.如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据

4.递归必须向退出递归的条件逼近，否则就是无限递归，死循环

5.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

解决问题：

1.打印问题

public static void test(int n) {
    if (n > 2) {
        test(n - 1);
    }//else {
    System.out.println("n=" + n);
    //}
}

2.阶乘问题

public static int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return factorial(n - 1) * n;
    }
}

递归-迷宫问题

说明：
1.小球得到的路径，和程序员设置的找路径策略有关，即找路的上下左右的顺序相关

2.在得到小球路径时，先可以使用（上下左右），再改成（上右下左），看看路径是不是有变化

3.测试回溯现象

package com.ren.recursion;

public class MiGong {
    public static void main(String[] args) {
        //先创建一个二维数组，模拟迷宫
        //地图
        int[][] map = new int[8][7];
        //使用1表示墙
        //上下全部置为1
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        //左右全部置为1
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //设置挡板
        map[3][1] = 1;
        map[3][2] = 1;
        //造成回溯
        /*map[1][2] = 1;
        map[2][2] = 1;*/
        //输出地图
        System.out.println("地图的情况");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }

        //使用递归回溯给小球找路
        setWay(map,1,1);

        //输出新的地图,小球走过，并标识过的地图
        System.out.println("小球走过地图的情况");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }

    }
    //使用递归回溯来给小球找路
    //说明
    //1.map 表示地图
    //2.i，j 表示从哪个位置开始找（1，1）
    //3.如果小球能到[6][5]位置，说明通路找到
    //4.约定：当map[][] = 0表示该点没有走过，当为1表示墙，2表示通路可以走，3表示该店已经走过，但是走不通
    //5.再走迷宫时，需要确定一个策略（方法），下==》右==》上==》左，如果该点走不通，在回溯

    /**
     * @param map 表示地图
     * @param i   表示从哪个位置开始找
     * @param j
     * @return 如果找到通路，就返回true ，否则返回false
     */
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//通路已经找到
            return true;
        } else {
            if (map[i][j] == 0) {//如果该点还没有走过
                //按照策略下右上左
                map[i][j] = 2;//假定该点是可以走通
                if (setWay(map, i + 1, j)) {//向下走
                    return true;
                } else if (setWay(map, i, j + 1)) {//向右走
                    return true;
                } else if (setWay(map, i - 1, j)) {//向上走
                    return true;
                } else if (setWay(map, i, j - 1)) {//向左走
                    return true;
                } else {
                    //说明该点是走不通的
                    map[i][j] = 3;
                    return false;
                }
            }else {//如果map[i][j]!=0,可能是1，2，3
                return false;
            }
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0QLU4V03-1659770049263)(C:\Users\任朝辉\AppData\Roaming\Typora\typora-user-images\image-20220731121520203.png)]

递归-八皇后问题(回溯算法)

在8*8的棋盘中，任意两个皇后都不能处于同一行或同一斜线上，有多少种摆法

思路分析

1、第一个皇后先放在第一行第一列

2、第二个皇后放在第二行第一列，然后判断是否ok，如果不ok，继续放在第二列，第三列，依次把所有列都放完，找到一个合适

3、继续第三个皇后，还是第一列，第二列。。。直到第8个皇后也能放在一个不冲突的位置，算是找到一个正确解

4、当得到一个正确解时，在站回退到上一个栈中，就会开始回溯，即将第一个皇后放在第一列的所有正确解，全部得到

5、然后回头继续第一个皇后放在第二列，后面继续循环执行1，2，3，4的步骤

说明：理论上应该可以创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题

arr[8] = {0,4,7,5,2,6,1,3}对应arr下标表示第几行，即第几个皇后，arr[i] = val,val表示第i+1个皇后，放在第i+1行的第val+1列

package com.ren.recursion;

public class Queue8 {
    //定义一个max表示共有多少个皇后
    int max = 8;
    //定义一个array，保存皇后放置位置的结果，比如arr[8] = {0,4,7,5,2,6,1,3}
    int[] array = new int[max];
    static int count = 0;

    public static void main(String[] args) {
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.println("一共有" + count + "次解法");
    }

    //编写一个方法，放置第n个皇后
    //特别注意：check是每一次递归时，进入check中都有for (int i = 0; i < max; i++)，因此会回溯
    private void check(int n) {
        if (n == max) {//说明8个皇后已经放好了
            print();
            return;
        }
        //依次放入皇后，并判断是否冲突
        for (int i = 0; i < max; i++) {
            //先把当前的皇后n，放到该行的第1列
            array[n] = i;
            //判断当放置第n个皇后到i列时，是否冲突
            if (judge(n)) {//不冲突
                //接着放n+1个皇后，即开始递归
                check(n + 1);
            }
            //如果冲突，就继续执行array[n]= i;即将第n个皇后，放置在本行的后移的一个位置

        }
    }
    //查看当我们放置第n个皇后时，就去检测该皇后是否和前面已经摆放的黄后冲突

    /**
     * @param n 表示第n个皇后
     * @return 是否冲突
     */
    private boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //说明
            //array[i] == array[n] 表示判断第n个皇后是否和前面的n-1个皇后在同一列
            //Math.abs(n-i)==Math.abs(array[n]-array[i]) 表示判断第n个皇后与第i个皇后是否在同一斜线上
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    //写一个方法，可以将皇后摆放的位置输出
    private void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}