数据结构和算法

稀疏数组

实际需求与分析

先来看一个实际需求，比较好思考

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

我们首先能想到的就是使用一个 二维数组，如上图所示：

• 0：表示没有棋子
• 1：表示黑棋
• 2：表示蓝棋

可以看到二维数组中很多值都是 0，因此记录了很多没有意义的数据。

因此当一个数组中 大部分元素为 0（或是同一个值） 时，可以使用 稀疏数组 来保存该数组

稀疏数组和二维数组的转换

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

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

稀疏数组转原始的二维数组的思路

• 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chesArr2=int[11][11]
• 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.

具体代码实现

package SparseArray;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Arrays;

public class SparseArray {
    public static void main(String[] args) {
        try {
            // 棋盘问题
            // 创建一个 二维数组 存储棋子 11*11 0表示没有棋子 1表示黑色棋子 2表示蓝色棋子
            int chessArrs[][] = new int[11][11];
            chessArrs[1][2] = 1;
            chessArrs[2][3] = 2;
            chessArrs[3][4] = 2;
            // 遍历二维数组
            System.out.println("------------------------------二维数组--------------------------------------");
            for (int[] row : chessArrs) {
                for (int data : row) {
                    System.out.printf("%d\t", data);
                }
                System.out.println();
            }
            System.out.println("---------------------------------------------------------------------------");
            // 记录 非0 数据的 个数
            int sum = 0;
            for (int[] row : chessArrs) {
                for (int data : row) {
                    if (data != 0) {
                        sum++;
                    }
                }
            }
            System.out.println("有效数值(非0数值)" + sum);
            // 创建稀疏数组
            int count = 0;
            int sparseArray[][] = new int[sum + 1][3];
            // 第一行存放 二维数组的行 和列
            sparseArray[0][0] = 11;
            sparseArray[0][1] = 11;
            // 存放有效数字（非0数值）
            sparseArray[0][2] = sum;
            System.out.println("------------------------------稀疏数组--------------------------------------");
            for (int i = 0; i < chessArrs.length; i++) {
                for (int j = 0; j < chessArrs[i].length; j++) {
                    if (chessArrs[i][j] != 0) {
                        count++;
                        sparseArray[count][0] = i;
                        sparseArray[count][1] = j;
                        sparseArray[count][2] = chessArrs[i][j];
                    }
                }
            }
            // 存储稀疏数组 数据到 文件
            PrintWriter pw = new PrintWriter("src/sparseArray.txt");
            for (int[] s : sparseArray) {
                for (int data : s) {
                    pw.print(data + "\t");
                }
                pw.println();
            }
            pw.flush();
            pw.close();
            // 输出稀疏数组
            for (int i = 0; i < sum + 1; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.printf("%d\t", sparseArray[i][j]);
                }
                System.out.println();
            }
            // 将稀疏数组转化为二维数组
            int recover[][] = new int[sparseArray[0][0]][sparseArray[0][1]];
            // 给恢复的二维数组赋值
            for (int i = 1; i < sparseArray.length; i++) {
                recover[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
            }
            System.out.println("------------------------------恢复数组--------------------------------------");
            // 遍历恢复二维数组
            for (int[] recovers : recover) {
                for (int data : recovers) {
                    System.out.printf("%d\t", data);
                }
                System.out.println();
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

队列

队列是一个有序的列表，特点是先进先出。

代码实现

package Queue;

import java.util.Scanner;
// 数组模拟使用队列 会导致 数组只被使用一次  而被遗弃 不能添加 数据  不能重复使用

public class QueueArray {
    public static void main(String[] args) {
        // 初始化队列
        queue queue = new queue(3);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("---------------------------------队列----------------------------");
            System.out.println("请选择");
            System.out.println("s(show):显示队列数据");
            System.out.println("a(add): 添加队列数据");
            System.out.println("g(get): 出队列");
            System.out.println("h(header):显示头数据");
            String que = scanner.next();
            switch (que) {
                case "s":
                    try {
                        queue.showQueue();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "a":
                    System.out.println("请输入需要添加的数据");
                    int n = scanner.nextInt();
                    try {
                        queue.AddQueue(n);
                    } catch (Exception e) {
                    }
                    break;
                case "g":
                    try {
                        int queue1 = queue.getQueue();
                        System.out.println("取出的队列数据是" + queue1);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "h":
                    try {
                        int header = queue.getHeader();
                        System.out.println("头部的队列数据是" + header);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
            }
        }

    }
}

class queue {
    private int maxSize; //队列的最大容量
    private int fronts; // 队列头 前面的一位
    private int rears; // 队列尾部
    private int[] queueArray; // 队列数组

    public queue(int maxSize) {
        this.maxSize = maxSize;
        queueArray = new int[maxSize];
        fronts = -1;
        rears = -1;
    }

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

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

    // 添加数据到队列
    public void AddQueue(int n) {
        if (isFull()) {
            System.out.println("队列已经满了,暂时不能加入,请等待");
            return;
        }
        queueArray[++rears] = n;
    }

    // 出队列
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空的");
        }
        return queueArray[++fronts];
    }

    // 获取队列的所有数据
    public void showQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空的");
        }
        for (int i = 0; i < queueArray.length; i++) {
            System.out.println("arr[" + i + "]=" + queueArray[i]);
        }
    }

    // 获取队列头数据 不是取出数据
    public int getHeader() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空的");
        }
        return queueArray[fronts + 1];
    }
}

链表

链表是一个非连续存储的数据结构，特点是当前节点指向下一个节点，链式存储。

单链表

单链表添加以及遍历思路

单链表删除思路

单链表反转思路(腾讯面试题)

单链表实现代码

package Linked.SingleLinked;

import java.util.Stack;

public class linked {
    public static void main(String[] args) {
        Animals animals1 = new Animals(1, "猫");
        Animals animals2 = new Animals(2, "狗");
        Animals animals3 = new Animals(3, "兔");
        Animals animals4 = new Animals(4, "鱼");
        SingleLinkedList list = new SingleLinkedList();
        list.add(animals1);
        list.add(animals3);
        list.add(animals2);
        list.add(animals4);
        // 修改节点
        list.update(new Animals(1, "猫咪"));
        // 删除节点
//        list.delete(1);
        list.list();
        // 获取链表长度
        System.out.println("有效节点个数：" + list.getLength(list.getHead()));
        // 获取倒数第n个节点[新浪面试题]
        System.out.println("倒数第2个节点：" + list.getLastIndex(list.getHead(), 2));

        System.out.println("---------------------------------反转链表-------------------------------");
        list.reverse(list.getHead());
        list.list();
        System.out.println("---------------------------------逆序打印-------------------------------");
        // 逆序打印链表
        list.reversePrint(list.getHead());
    }
}

class SingleLinkedList {
    // 初始化一个头节点
    private Animals head = new Animals(0, "");

    public Animals getHead() {
        return head;
    }

    // 修改节点的信息,根据node编号来修改
    public void update(Animals animals) {
        // 找到需要修改的节点, 根据node编号
        Animals temp = head.next;
        // 标志 是否找到该节点
        boolean flag = false;
        // 遍历链表
        while (true) {
            // 已经遍历完链表
            if (temp == null) {
                break;
            }
            if (temp.node == animals.node) {
                // 找到
                flag = true;
                break;
            }
            // 后移，遍历当前链表
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if (flag) {
            temp.name = animals.name;
        } else {
            System.out.println("未找到");
        }
    }

    // 有序添加节点
    public void addOrder(Animals animals) {
        // 创建辅助变量
        Animals temp = head;
        // 标志 是否存在该节点
        boolean flag = false;
        // 遍历链表
        while (true) {
            if (temp.next == null) { // 已经到链表的最后
                break;
            } else if (temp.next.node > animals.node) {// 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.node == animals.node) {
                // 说明希望添加的node已经存在
                flag = true;
                break;
            }
            // 后移，遍历当前链表
            temp = temp.next;
        }
        // 判断flag的值
        if (flag) { // 说明希望添加的node已经存在
            System.out.println("已经存在该节点");
            return;
        }
        // 插入到链表中，temp的后面
        animals.next = temp.next;
        temp.next = animals;
    }

    // 添加节点到链表
    public void add(Animals animals) {
        // 创建辅助变量，帮助定位到最后
        Animals temp = head;
        // 遍历链表，找到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            // 后移
            temp = temp.next;
        }
        // 将最后这个节点的next指向新的节点
        temp.next = animals;
    }

    // 删除节点
    public void delete(int node) {
        // 创建辅助变量
        Animals temp = head;
        // 标志 是否找到待删除节点的前一个节点
        boolean flag = false;
        while (true) {
            if (temp.next == null) {// 已经到链表的最后
                break;
            }
            if (temp.next.node == node) {// 找到待删除节点的前一个节点
                flag = true;
                break;
            }
            // 后移，遍历当前链表
            temp = temp.next;
        }
        // 判断flag
        if (flag) {// 找到
            temp.next = temp.next.next;
        } else {
            System.out.println("未找到该节点");
        }
    }

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

    // 获取链表的长度
    public int getLength(Animals head) {
        // 判断链表是否为空
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        // 定义一个辅助的变量, 这里我们没有统计头节点
        Animals cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next; // 遍历
        }
        return length;
    }

    // 查找单链表中的倒数第k个节点【新浪面试题】
    public Animals getLastIndex(Animals head, int index) {
        // 判断链表是否为空
        if (head.next == null) {
            return null;
        }
        // 第一个遍历得到链表的长度(节点个数)
        int size = getLength(head);
        // 第二次遍历 size-index位置，就是我们倒数的第k个节点
        // 先做一个index的校验
        if (index <= 0 || index > size) {
            return null;
        }
        // 定义辅助变量
        Animals cur = head.next;
        // 第三次遍历 size-index位置，就是我们倒数的第k个节点
        for (int i = 0; i < size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    // 反转链表【腾讯面试题，有点难度】
    public void reverse(Animals head) {
        // 如果当前链表为空，或者只有一个节点，无需反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        // 定义一个辅助的指针(变量)，帮助我们遍历原来的链表
        Animals cur = head.next;
        Animals next = null; // 指向当前节点[cur]的下一个节点
        Animals reverseHead = new Animals(0, "");
        // 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
        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 void reversePrint(Animals head) {
        if (head.next == null) {
            return; // 空链表，不能打印
        }
        // 创建要给一个栈，将各个节点压入栈
        Stack<Animals> stack = new Stack<>();
        Animals cur = head.next;
        // 将链表的所有节点压入栈
        while (cur != null) {
            stack.push(cur);
            cur = cur.next; // cur后移，这样就可以压入下一个节点
        }
        // 将栈中的节点进行打印, pop 出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop()); // stack的特点是先进后出
        }
    }
}
class Animals {
    // 节点编号
    public Integer node;
    public String name;
    // 指向下一个节点
    public Animals next;

    public Animals(Integer node, String name) {
        this.node = node;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animals{" +
                "node=" + node +
                ", name='" + name + '\'' +
                ", next=" + next +
                '}';
    }
}

双向链表

双向链表不同于单向链表，由于指向是双向的它可以自我删除，不需要依赖辅助节点、可以向前向后查找。

代码实现

package Linked.DoubleLined;

public class DoubleLinkedDemo {
    public static void main(String[] args) {
        DoubleLinked db = new DoubleLinked();
        Fruit fruit = new Fruit(1, "苹果");
        Fruit fruit2 = new Fruit(2, "香蕉");
        Fruit fruit3 = new Fruit(3, "橙子");
        Fruit fruit4 = new Fruit(4, "葡萄");
        db.add(fruit);
        db.add(fruit2);
        db.add(fruit3);
        db.add(fruit4);
        db.delete(4);
        // 修改
        db.update(new Fruit(1, "梨子"));
        db.list();
    }
}


class DoubleLinked {
    // 初始化头节点
    private Fruit head = new Fruit(0, "");

    // 添加
    public void add(Fruit fruit) {
        // 找到最后一个节点
        Fruit temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        // 将节点添加到链表末尾
        temp.next = fruit;
        fruit.pre = temp;
    }

    // 遍历
    public void list() {
        // 找到第一个节点
        Fruit temp = head.next;
        if (temp == null) {
            System.out.println("链表为空");
        }
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    // 删除，由于是双向链表，删除时只需要删除对应的节点
    public void delete(int id) {
        // 找到第一个节点
        Fruit temp = head.next;
        boolean flag = false;
        if (temp.next == null) {
            System.out.println("链表为空");
            return;
        }
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.id == id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 根据标志进行删除操作
        if (flag) {
            temp.pre.next = temp.next;
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.println("无效节点信息");
        }
    }

    // 修改
    public void update(Fruit fruit) {
        // 找到第一个节点
        Fruit temp = head;
        boolean flag = false;
        // 遍历
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (fruit.id == head.next.id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next.name = fruit.name;
        } else {
            System.out.println("无效节点信息");
        }
    }
}

class Fruit {
    public int id;
    public String name;
    public Fruit next;
    public Fruit pre;

    public Fruit(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Fruit{" +
                "id=" + id +
                ", name='" + name +
                '}';
    }
}

递归

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

案例

阶乘和打印

package Recursion.recursion;

public class recursion {
    public static void main(String[] args) {
        testRecursion(4);
        System.out.println(factorial(3));
    }

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

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

递归本质上其实是一个压栈操作。

递归需要遵守的重要规则

• 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

• 从方法的局部变量是独立的，不会相互影响、比如 n 变量

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

• 递归必须向退出递归的条件逼近，否则就是无限递归,出现 StackOverflowError，死龟了:)4)

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

迷宫问题

迷宫问题（回溯），上图说明：

• 红色的方块是围墙，是小球不能够走的
• 白色的方块是小球可以活动的范围
• 左上角是小球的起点，移动到右下角，就算走出了迷宫

package Recursion.MazeProblem;

public class MazeProblem {
    public static void main(String[] args) {
        // 创建一个迷宫 7行 8列
        int maze[][] = new int[8][7];
        maze[2][1] = 1;
        maze[2][2] = 1;
        // 设置边界墙壁
        for (int i = 0; i < 8; i++) {
            maze[i][0] = 1;
            maze[i][6] = 1;
        }
        for (int i = 0; i < 7; i++) {
            maze[0][i] = 1;
            maze[7][i] = 1;
        }
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------------------------------");
        // 实现迷宫寻路
        setWay(maze, 1, 1);
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }

    }

    // 递归
    // 1. 墙壁表示1  0 表示未走过的路径 2表示走过的路径 3表示死路
    public static boolean setWay(int maze[][], int i, int j) {
        // 判断是否到达终点
        if (maze[6][5] == 2) {
            return true;
        } else {// 如果没有到达终点，则继续探索可行路径
            // 默认按照下右上左的顺序探索
            if (maze[i][j] == 0) {
                maze[i][j] = 2;
                if (setWay(maze, i + 1, j)) {//向下
                    return true;
                } else if (setWay(maze, i, j + 1)) {//向右
                    return true;
                } else if (setWay(maze, i - 1, j)) {//向上
                    return true;
                } else if (setWay(maze, i, j - 1)) {//向左
                    return true;
                } else {
                    maze[i][j] = 3;
                    return false;
                }
            } else {// 如果不为0，则为1、2、3
                return false;
            }
        }
    }
}

栈

相比于队列，栈的特征就是先进后出。

使用数组来模拟栈

代码实现

package Stack.ArrayStack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 初始化
        StackImpl stack = new StackImpl(5);
        while (true) {
            System.out.println("---------------------------------执行操作指令---------------------------------");
            System.out.println("1.压栈");
            System.out.println("2.弹栈");
            System.out.println("3.查看栈");
            int answer = scanner.nextInt();
            if (answer == 1) {
                System.out.println("请输入要压入的数据");
                int value = scanner.nextInt();
                stack.push(value);
            }
            if (answer == 2) {
                System.out.println("取出的数据为：" + stack.pop());

            }
            if (answer == 3) {
                stack.list();
            }
        }
    }
}

class StackImpl {
    private int maxSize;
    private int top; // 表示栈顶
    private int[] stack;

    public StackImpl(int maxSize) {
        this.maxSize = maxSize;
        top = -1;
        stack = new int[maxSize];
    }

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

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

    // 压栈
    public void push(int n) {
        if (isFull()) {
            System.out.println("栈已满");
            return;
        }
        stack[++top] = n;
    }

    // 弹栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        return stack[top--];
    }

    // 打印栈
    public void list() {
        for (int i = top; i >= 0; i--) {
            System.out.println("arr[" + i + "]=" + stack[i]);
        }
    }
}

使用栈实现一个计算器

思路如下

代码如下

package Stack.OperStack;

public class Calculator {
    public static void main(String[] args) {

        String expression = "15*3+6";
        // 创建两个栈，一个存放数值，一个存放运算符
        StackOper stackOper = new StackOper(10);
        StackOper stackNum = new StackOper(10);
        // 临时变量和结果变量
        int n1 = 0;
        int index = 0;
        int n2 = 0;
        int res = 0;
        int oper = 0;
        char ch = ' ';// 每次扫描得到的字符保存到ch
        String keepNum = "";
        while (true) {
            // 一次取出一个字符进行处理
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断是否为运算符
            if (stackOper.isOper(ch)) {
                // 判断运算符栈是否为空
                if (!stackOper.isEmpty()) {
                    // 判断当前运算符的优先级是否小于等于栈顶运算符的优先级
                    if (stackOper.priority(ch) <= stackOper.priority(stackOper.peek())) {
                        // 弹出栈顶的数和运算符 进行运算
                        n1 = stackNum.pop();
                        n2 = stackNum.pop();
                        oper = stackOper.pop();
                        res = stackNum.cal(n1, n2, oper);
                        // 将运算结果压入数值栈
                        stackNum.push(res);
                        // 然后将当前的运算符压入运算符栈
                        stackOper.push(ch);

                    } else {// 当前运算符优先级大于栈顶运算符，直接入栈
                        stackOper.push(ch);
                    }
                } else { // 栈空直接入栈
                    stackOper.push(ch);
                }

            } else {// 数值直接入栈
                // stackNum.push(ch - 48);//因为 字符数字的Ascall值与 48 相差，所以需要字符数字减去 48 转为真正的数字
                keepNum += ch;

                if (index == expression.length() - 1) {
                    stackNum.push(Integer.parseInt(keepNum));
                } else {
                    if (stackNum.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        stackNum.push(Integer.parseInt(keepNum));
                        keepNum = "";
                    }
                }

            }
            index++;
            // 判断是否扫描到表达式末尾
            if (index >= expression.length()) {
                break;
            }
        }
        // 对表达式进行扫描完毕，依次从运算符栈和数值栈取出对应的数据，进行计算
        while (true) {
            if (stackOper.isEmpty()) {
                break;
            }
            n1 = stackNum.pop();
            n2 = stackNum.pop();
            oper = stackOper.pop();
            res = stackNum.cal(n1, n2, oper);
            stackNum.push(res);
        }
        System.out.println(stackNum.pop());

    }

}

class StackOper {
    private int maxSize;
    private int top; // 表示栈顶
    private int[] stack;

    public StackOper(int maxSize) {
        this.maxSize = maxSize;
        top = -1;
        stack = new int[maxSize];
    }

    // 获取栈顶元素
    public int peek() {
        return stack[top];
    }

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

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

    // 入栈
    public void push(int n) {
        if (isFull()) {
            System.out.println("栈已满");
            return;
        }
        stack[++top] = n;
    }

    // 出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        return stack[top--];
    }

    // 遍历栈
    public void list() {
        for (int i = top; i >= 0; i--) {
            System.out.println("arr[" + i + "]=" + stack[i]);
        }
    }

    // 判断是否为运算符
    public boolean isOper(char ch) {
        return ch == '*' || ch == '/' || ch == '+' || ch == '-';
    }

    // 判断运算符的优先级
    public int priority(int ch) {
        if (ch == '*' || ch == '/') {
            return 2;
        } else if (ch == '+' || ch == '-') {
            return 1;
        } else {
            return 0;
        }
    }

    // 进行运算
    public int cal(int n1, int n2, int oper) {
        int res = 0;
        switch (oper) {
            case '*':
                res = n1 * n2;
                break;
            case '/':
                res = n2 / n1;
                break;
            case '+':
                res = n1 + n2;
                break;
            case '-':
                res = n2 - n1;
                break;
        }
        return res;
    }
}

后缀表达式模拟计算器

思路

代码实现

package Stack.SuffixStack;

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

/**
 * 后缀表达式转中缀表达式: 1+((2+3)*4)-5
 * 1) 初始化两个栈：运算符栈s1和存储中间结果的栈s2
 * 2) 从左至右扫描后缀表达式
 * 3) 遇到操作数时，将其压入s2
 * 4) 遇到运算符时，比较其与s1栈顶运算符的优先级：
 * 1. 如果s1为空，或栈顶运算符为左括号"("，则直接将该运算符入栈
 * 2. 否则，若优先级比栈顶运算符高，也将运算符压入s1
 * 3. 否则，将s1栈顶运算符弹出并压入s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
 * 5) 遇到括号时：
 * 1. 如果是左括号"("，则直接压入s1
 * 2. 如果是右括号")"，则依次弹出s1栈顶的运算符并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
 * 6) 重复步骤2至5，直到表达式的最右边
 * 7) 将s1中剩余的运算符依次弹出并压入s2
 * 8) 由于s2中存储的是逆序的中缀表达式，将s2中的元素逆序输出，即得到中缀表达式对应的后缀表达式
 **/
// 后缀表达式模拟计算器
public class SuffixOper {
    public static void main(String[] args) {
        // 后缀表达式转中缀表达式
        // 示例：1+((2+3)*4)-5
        String expression = "1+((2+3)*4)-5";
        List<String> list = toMiddleExpression(expression);
        System.out.println(list);
        // 中缀转后缀
        List<String> suffix = getSuffix(list);
        System.out.println(suffix);
        // 计算结果
        System.out.println("计算结果：" + cal(suffix));
        // 示例：3 4 + 5 * 6 -     >>>  (3+4)*5-6
        // 示例：4*5-8+60+8/2   >>>> 4 5 * 8 - 60 + 8 2 / +
        //        String SuffixExpression="3 4 + 5 * 6 -";
        //       String SuffixExpression="4 5 * 8 - 60 + 8 2 / +";
        //        List<String> list = SuffixOper.getExpression(SuffixExpression);
//        System.out.println(SuffixOper.cal(list));
    }

    // 分割表达式（自定义）
    public static List<String> getExpression(String expression) {
        List<String> list = new ArrayList<>();
        // 将表达式按空格分割并加入列表中
        for (String element : expression.split(" ")) {
            list.add(element);
        }
        return list;
    }

    // 计算结果
    public static int cal(List<String> list) {
        // 栈用于存储中间结果和运算符
        Stack<String> stack = new Stack<>();
        // 遍历列表
        for (String el : list) {
            // 判断是否为数字 3 4 + 5 * 6 -
            if (el.matches("\\d+")) {
                // 入栈
                stack.push(el);
            } else {
                // 出栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                // 根据运算符进行计算
                if (el.equals("+")) {
                    res = num1 + num2;
                } else if (el.equals("-")) {
                    res = num1 - num2;
                } else if (el.equals("*")) {
                    res = num1 * num2;
                } else if (el.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符异常");
                }
                // 入栈
                stack.push(res + "");
            }
        }
        // 返回栈顶元素作为结果
        return Integer.parseInt(stack.pop());
    }

    // 中缀表达式转换为列表
    public static List<String> toMiddleExpression(String expression) {
        // 创建一个列表用于存储中缀表达式的元素
        List<String> list = new ArrayList<>();
        char c = ' ';
        char ch = ' ';
        // 用于拼接数字的字符串
        String str = "";
        int i = 0;
        do {
            // 判断是否为数字
            if ((c = expression.charAt(i)) < 48 || (c = expression.charAt(i)) > 57) {
                list.add(c + "");
                i++;
            } else {
                str = "";
                // 拼接数字
                while (i < expression.length() && (c = expression.charAt(i)) >= 48 && (c = expression.charAt(i)) <= 57) {
                    if (i < expression.length() - 1 && (ch = expression.charAt(i + 1)) >= 48 && (ch = expression.charAt(i + 1)) <= 57) {
                        str += ch;
                        i++;
                    } else {
                        str += c;
                        i++;
                    }
                }
                list.add(str);
            }
        } while (i < expression.length());
        return list;
    }

    // 字符串转列表
    public static List<String> toList(String expression) {
        List<String> list = new ArrayList<>();
        String[] split = expression.split(" ");
        for (String s : split) {
            list.add(s);
        }
        return list;
    }

    // 字符串分割
    public static List<String> Sub(String expression) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < expression.length(); i++) {
            String substring = expression.substring(i, i + 1);
            list.add(substring);
        }
        return list;
    }

    // 中缀表达式转后
// 中缀转后缀
    public static List<String> getSuffix(List<String> list) {
        // 初始化栈s1用于存储运算符，s2用于存储后缀表达式
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();

        // 遍历列表
        for (String s : list) {
            // 判断是否为数字
            if (s.matches("\\d+")) {
                // 如果是数字直接加入s2
                s2.add(s);
            } else {
                // 如果栈为空，直接将运算符压入栈s1
                if (s1.size() == 0) {
                    s1.push(s);
                } else {
                    // 如果栈不为空
                    if (s.equals("(")) {
                        // 如果是左括号，直接压入栈s1
                        s1.push(s);
                    } else if (s.equals(")")) {
                        // 如果是右括号，将s1中的运算符弹出并加入s2，直到遇到左括号为止，然后将左括号弹出
                        while (!s1.peek().equals("(")) {
                            s2.add(s1.pop());
                        }
                        s1.pop(); // 弹出左括号
                    } else {
                        // 其他情况，将s1中栈顶的运算符与当前运算符进行比较
                        // 如果栈顶运算符的优先级大于等于当前运算符，则将栈顶运算符弹出并加入s2，直到栈顶运算符的优先级小于当前运算符
                        while (s1.size() != 0 && SuffixPriority.getFirst(s1.peek()) >= SuffixPriority.getFirst(s)) {
                            // 将弹出的运算符加入s2
                            s2.add(s1.pop());
                        }
                        // 在退出循环后，将当前运算符压入s1
                        s1.push(s);
                    }
                }
            }
        }

        // 将s1中剩余的运算符依次弹出并加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2;
    }
}

class SuffixPriority {
    private static final int ADD = 1;
    private static final int Dec = 1;
    private static final int MUL = 2;
    private static final int DIV = 2;

    public static int getFirst(String Operation) {
        int result = 0;
        switch (Operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = Dec;
                break;
            case "/":
                result = DIV;
                break;
            case "*":
                result = MUL;
                break;
        }
        return result;
    }
}

8大排序

冒泡排序

冒泡排序的原理就是依次比较相邻的数，如果是从小到大，就将大数据往后沉。排序的过程就像水泡一样所以称之为冒泡排序。过程如下图

代码中演变过程:

package Test.bubble;

import java.util.Arrays;

public class bubble {
    public static void main(String[] args) {
        int arr[] = {1, 4, -1, 8, 6, 9, 3, 2, 7, 20};
        bubbleSort(arr);
        System.out.println("最终结果为"+Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        // 临时变量
        int temp = 0;
        // 控制变量
        // 第一轮排序，将最大值移动到最后
        for (int j = 0; j < arr.length - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第一次排序结果为:"+Arrays.toString(arr));
        // 第二轮排序，只需考虑到 arr.length-1 因为最大值已经确定
        for (int j = 0; j < arr.length - 2; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第二次排序结果为:"+Arrays.toString(arr));
        // 依此类推
        for (int j = 0; j < arr.length - 3; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第三次排序结果为:"+Arrays.toString(arr));
        for (int j = 0; j < arr.length - 4; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第四次排序结果为:"+Arrays.toString(arr));
        for (int j = 0; j < arr.length - 5; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第五次排序结果为:"+Arrays.toString(arr));
        for (int j = 0; j < arr.length - 6; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第六次排序结果为:"+Arrays.toString(arr));
        for (int j = 0; j < arr.length - 7; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第七次排序结果为:"+Arrays.toString(arr));
        for (int j = 0; j < arr.length - 8; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第八次排序结果为:"+Arrays.toString(arr));
        for (int j = 0; j < arr.length - 9; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第九次排序结果为:"+Arrays.toString(arr));
    }
}

运行结果如下

第一次排序结果为:[1, -1, 4, 6, 8, 3, 2, 7, 9, 20]
第二次排序结果为:[-1, 1, 4, 6, 3, 2, 7, 8, 9, 20]
第三次排序结果为:[-1, 1, 4, 3, 2, 6, 7, 8, 9, 20]
第四次排序结果为:[-1, 1, 3, 2, 4, 6, 7, 8, 9, 20]
第五次排序结果为:[-1, 1, 2, 3, 4, 6, 7, 8, 9, 20]
第六次排序结果为:[-1, 1, 2, 3, 4, 6, 7, 8, 9, 20]
第七次排序结果为:[-1, 1, 2, 3, 4, 6, 7, 8, 9, 20]
第八次排序结果为:[-1, 1, 2, 3, 4, 6, 7, 8, 9, 20]
第九次排序结果为:[-1, 1, 2, 3, 4, 6, 7, 8, 9, 20]
最终结果为[-1, 1, 2, 3, 4, 6, 7, 8, 9, 20]

简化写法的冒泡排序

 public static void bubbleSort(int arr[]) {
     // 临时变量，用于交换数据
     int temp = 0;
     // 第一层循环，控制比较的轮数
     for (int i = 0; i < arr.length - 1; i++) {
         for (int j = 0; j < arr.length - 1 - i; j++) {
             if (arr[j] > arr[j + 1]) {
                 temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
             }
         }
     }
 }

冒泡排序可以进行优化，如果在一轮交换后，数组中的数据都没有进行交换则可以跳出循环。

public static void bubbleSorts(int[] arr) {
    boolean flag = false;
    int temp = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                flag = true;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        if (!flag) {
            break;
        }
        flag = false;
    }
}

选择排序

基本思想为：

• 第一次从 arr[0]~arr[n-1] 中选取最小值，与 arr[0] 交换
• 第二次从 arr[1]~arr[n-1] 中选取最小值，与 arr[1] 交换
• 第 i 次从 arr[i-1]~arr[n-1] 中选取最小值，与 arr[i-1] 交换

依次类图，总共通过 n - 1 次，得到一个按排序码从小到大排列的有序序列

代码推理过程

package Sort.SelectSort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int []arr={5,3,7,1};
        selectSort(arr);
    }

    // 简单选择排序的实现
    public static void selectSort(int arr[]) {
        // 选择排序每次找到最小值的位置

        // 第一个最小值时arr[0]
        int minIndex = 0;
        int min = arr[0];
        // 第一次排序
        for (int j = 1; j < arr.length; j++) {
            if (arr[j] < min) {
                min = arr[j];
                minIndex = j;
            }
        }
        // 将最小值交换到arr[0]
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第一次排序后：" + Arrays.toString(arr));
        // 第二次排序
        minIndex = 1;
        min = arr[1];
        for (int j = 2; j < arr.length; j++) {
            if (arr[j] < min) {
                min = arr[j];
                minIndex = j;
            }
        }
        // 将最小值交换到arr[1]
        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第二次排序后：" + Arrays.toString(arr));
        // 第三次排序
        minIndex = 2;
        min = arr[2];
        for (int j = 3; j < arr.length; j++) {
            if (arr[j] < min) {
                min = arr[j];
                minIndex = j;
            }
        }
        // 将最小值交换到arr[2]
        if (minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第三次排序后：" + Arrays.toString(arr));
    }
}

计算结果

第一次排序后：[1, 3, 7, 5]
第二次排序后：[1, 3, 7, 5]
第三次排序后：[1, 3, 5, 7]

简化写法

 public static void selectSorts(int[] arr) {
     for (int i = 0; i < arr.length - 1; i++) {
         int min = arr[i];
         int minIndex = i;
         for (int j = i + 1; j < arr.length; j++) {
             if (arr[j] < min) {
                 min = arr[j];
                 minIndex = j;
             }
         }
         arr[minIndex] = arr[i];
         arr[i] = min;
         System.out.println("第"+(i+1)+"轮交换数据:"+Arrays.toString(arr));
     }
 }

运行结果

第1轮交换数据:[1, 3, 7, 5]
第2轮交换数据:[1, 3, 7, 5]
第3轮交换数据:[1, 3, 5, 7]

可以发现第2轮交换时，3本身就是最小的，但是还是进行了一次交换，所以我们可以从这个地方进行优化

 public static void selectSorts(int[] arr) {
     for (int i = 0; i < arr.length - 1; i++) {
         int min = arr[i];
         int minIndex = i;
         for (int j = i + 1; j < arr.length; j++) {
             if (arr[j] < min) {
                 min = arr[j];
                 minIndex = j;
             }
         }
         // 选择排序优化 如果这一轮中自己就是最小值则不需要交换
         if (minIndex != i) {
             // 在选择排序中找到最小值的索引并进行交换
             arr[minIndex] = arr[i];
             arr[i] = min;
             System.out.println("第" + (i + 1) + "轮交换数据:" + Arrays.toString(arr));
         }
     }
 }

运行结果

第1轮交换数据:[1, 3, 7, 5]
第3轮交换数据:[1, 3, 5, 7]

希尔排序

插入排序存在一个缺点，例如数组arr = {2,3,4,5,6,1}

展示的是要移动 1 这个数，的过程，由于在最后，需要前面的所有数都往后移动一位
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}

当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响，希尔排序是对插入排序的一个增强。

原始数组

初始步长为 gap=length/2，那么意味着整个数组被分为五组，分别是[8,3],[9,5],[1,4],[7,6],[2,0]，因为步长是5，所以 数组 索引0 和5 对应的值分为一组，以此类推。

对以上五组数据分别插入排序，得到以下结果

然后缩小增量 gap = 5 / 2 = 2，则数组被分为 2 组 [3,1,0,9,7] 和 [5,6,8,4,2]

对以上两组数据进行插入排序

然后再缩小增量 gap = 2 / 2 = 1，则整个数组被当成一组，再进行一次直接插入排序。由于基本上是有序的了，所以少了很多次的调整

希尔排序的推演过程

 // 希尔排序的实现
    public static void ShellSort(int[] arr) {
        // 根据步长进行分组，初始步长为数组长度的一半
        // 通过交换实现每个分组内的插入排序，逐渐减小步长直到为1

        int temp = 0;
        // 第一次分组，步长为10/2=5
        for (int i = 5; i < arr.length; i++) {
            for (int j = i - 5; j >= 0; j -= 5) {
                if (arr[j] > arr[j + 5]) {
                    temp = arr[j];
                    arr[j] = arr[j + 5];
                    arr[j + 5] = temp;
                }
            }
        }
        System.out.println("第一次分组后：" + Arrays.toString(arr));
        // 第二次分组，步长为5/2=2
        for (int i = 2; i < arr.length; i++) {
            for (int j = i - 2; j >= 0; j -= 2) {
                if (arr[j] > arr[j + 2]) {
                    temp = arr[j];
                    arr[j] = arr[j + 2];
                    arr[j + 2] = temp;
                }
            }
        }
        System.out.println("第二次分组后：" + Arrays.toString(arr));
        // 第三次分组，步长为2/2=1
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("第三次分组后：" + Arrays.toString(arr));
    }

结果为

第一次分组后：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
第二次分组后：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
第三次分组后：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

希尔排序-交换法代码

    public static void ShellSort3(int[] arr) {
        int temp = 0;
        // 希尔排序
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }

希尔排序-移动法

    // 希尔排序的实现
    public static void ShellSort2(int[] arr) {
        // 根据步长进行分组，初始步长为数组长度的一半
        // 通过插入排序实现每个分组内的排序，逐渐减小步长直到为1

        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                // 保存当前元素
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        // 向前移动元素
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    // 将temp插入到正确位置
                    arr[j] = temp;
                }
            }
        }
    }