Java数据结构与算法-java数据结构与算法（三）

package com.hyc.DataStructure.Stack;
import java.util.Scanner;
/**
 * @projectName: DataStructure
 * @package: com.hyc.DataStructure.Stack
 * @className: ArrayStackDemo
 * @author: 冷环渊 doomwatcher
 * @description: TODO 用数组来模拟栈
 * @date: 2021/12/23 18:08
 * @version: 1.0
 */
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("程序退出~~~");
    }
}
class ArrayStack {
    //栈的最大长度
    private int MaxSize;
    //模拟栈 数据就放在这个数组里
    private int[] stack;
    // 等于栈顶 默认等于-1 代表最底部分
    private int top = -1;
    public ArrayStack() {
    }
    // 初始化栈
    public ArrayStack(int maxSize) {
        MaxSize = maxSize;
        stack = new int[maxSize];
    }
    //返回栈顶 只是显示 并不是 pop 不会改变栈的结构
    public int peek() {
        return stack[top];
    }
    //判断栈是否是满的
    public boolean isFull() {
        return top == MaxSize - 1;
    }
    //判断栈 是否是空的
    public boolean isempty() {
        return top == -1;
    }
    //将数据压入栈
    public void push(int data) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = data;
    }
    //    将数据取出栈
    public int pop() {
        if (isempty()) {
            throw new RuntimeException("栈是空的 无法取出");
        }
        int value = stack[top];
        top--;
        return value;
    }
    //遍历栈 遍历的时候需要从栈顶开始显示数据
    public void list() {
        if (isempty()) {
            System.out.println("栈是空的");
        }
        //   从栈顶开始输出 其实就是倒序的输出数组 
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}

package com.hyc.DataStructure.Stack;
/**
 * @projectName: DataStructure
 * @package: com.hyc.DataStructure.Stack
 * @className: ListStackDemo
 * @author: 冷环渊 doomwatcher
 * @description: TODO 用链表来模拟栈
 * @date: 2021/12/23 18:23
 * @version: 1.0
 */
public class ListStackDemo {
    public static void main(String[] args) {
        listStack listStack = new listStack();
        listStack.push(5);
        listStack.push(6);
        listStack.push(9);
        System.out.println("出栈前");
        listStack.list();
        System.out.println("出栈后");
        System.out.println("出栈：" + listStack.pop());
        System.out.println("出栈：" + listStack.pop());
        listStack.list();
    }
}
class listStack {
    //创建一个头结点
    StackNode head = new StackNode(0);
    StackNode temp = head;
    //判断是否为空
    public boolean isempty() {
        return head.next == null;
    }
    //压入栈
    public void push(int value) {
        //创建节点对象
        StackNode newnode = new StackNode(value);
        //改变头节点指针的指向
        temp.next = newnode;
        //指针后移
        temp = temp.next;
    }
    //出栈
    public int pop() {
        if (isempty()) {
            throw new RuntimeException("栈空");
        }
        StackNode Before = head;
        //将 before 节点遍历到 temp也就是最后一个节点的上一个节点，让temp指针想前遍历
        while (true) {
            if (Before.next == temp) {
                break;
            }
            Before = Before.next;
        }
        //将before的下一个节点为空相当于出栈之后 删除引用
        Before.next = null;
        //取值
        int value = temp.data;
        //此时 before指向的这个节点就是上一个节点的位置，将temp前移动，重复操作实现出栈
        temp = Before;
        return value;
    }
    //遍历栈
    public void list() {
        //    判断非空
        if (isempty()) {
            System.out.println("栈是空的");
            return;
        }
        StackNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            System.out.println(temp.next.data);
            temp = temp.next;
        }
    }
}
//单向链表节点
class StackNode {
    // 数据
    public int data;
    //下一个节点
    public StackNode next;
    public StackNode(int data) {
        this.data = data;
    }
    //方便输出语句输出
    @Override
    public String toString() {
        return "StackNode{" +
                ", data='" + data + '\'' +
                ", next=" + next +
                '}';
    }
}

package com.hyc.DataStructure.Stack;
/**
 * @projectName: DataStructure
 * @package: com.hyc.DataStructure.Stack
 * @className: Calculator
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2021/12/24 20:39
 * @version: 1.0
 */
public class Calculator {
    public static void main(String[] args) {
        //  根据文章的思路 我们这里完成对一串计算只包含加减乘除的表达式运算操作
        String expression = "3+2*6-2";
        /** 计算思路 使用栈完成表达式的计算思路
         * 1.通过一个index值（素引）,来遍历我们的表达式
         * 2.如果我们发现是一个数字，就直接入数栈
         * 3.如果发现扫描到是一个符号，就分如下情况
         * 3.1如果发现当前的符号栈为空，就直接入栈
         * 3.2如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中
         * 的操作符，就需要从数栈中pop出两个数在从符号栈中pop出一个符号，进行运算，
         * 将得到结果，入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大
         * 于栈中的操作符，就直接入符号找。
         * 4.当表达式扫描完毕，就顺序的从数楼和符号栈中pop出相应的数和符号，并运行.
         * 5.最后在数栈只有一个数字，就是表达式的结果
         * 验证：3+2*6-2=13
         * 这里我们就根据上面的思路实现接下来的思路
         * */
        // 创建两个栈 一个存放需要计算的数字 一个存放需要运算的符号
        ArrayCalStack numStack = new ArrayCalStack(10);
        ArrayCalStack operStack = new ArrayCalStack(10);
        //    定义相关变量
        int index = 0; //用于指针扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        //将每次扫描得到的char保存到ch
        char ch;
        //用于萍姐多位数
        String keepNums = "";
        //开始while 循环扫描表达式 expression
        while (true) {
            //    一次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //    判断ch 是什么（数字或者符号）之后进行操作
            if (operStack.isOper(ch)) {
                /*   如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中
                 * 的操作符，就需要从数栈中pop出两个数在从符号栈中pop出一个符号，进行运算，
                 * 将得到结果，入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大
                 * 于栈中的操作符，就直接入符号找。*/
                //非空判断
                if (!operStack.isempty()) {
                    if (operStack.priotrity(ch) <= operStack.priotrity(operStack.peek())) {
                        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 {
                //  如果是数字 就直接进入数字栈
                /*思路
                 * 这里我们要考虑到多位数 在处理多位数的时候
                 *  我们需要扫描这个数的下一位一直到找到下一个符号
                 * 这个时候我们定义一个字符串用于拼接找到的数
                 * */
                //    处理多位数
                keepNums += ch;
                //    如果ch已经是 expression 最后一位name就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNums));
                } else {
                    //    判断下一个字符是不是数字 ，如果是就继续向下判断 是运算符则入栈，这里我们要看的是结束的地方是不是符号
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        //如果最后一位事原酸父则如入栈 这里我们的操作变化就是 keepnums =1 或者是 keepnums = 123
                        numStack.push(Integer.parseInt(keepNums));
                        //    加入之后能讲 keepnunms清空 用于下一位的判断
                        keepNums = "";
                    }
                }
            }
            //    让 index +1 并判断是否扫描到expression 最后
            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);
    }
}
/*
 *  应为要实现计算器 我们需要编写一些新的功能，
 * */
class ArrayCalStack {
    //栈的最大长度
    private int MaxSize;
    //模拟栈 数据就放在这个数组里
    private int[] stack;
    // 等于栈顶 默认等于-1 代表最底部分
    private int top = -1;
    public ArrayCalStack() {
    }
    // 初始化栈
    public ArrayCalStack(int maxSize) {
        MaxSize = maxSize;
        stack = new int[maxSize];
    }
    //返回栈顶 只是显示 并不是 pop 不会改变栈的结构
    public int peek() {
        return stack[top];
    }
    //判断栈是否是满的
    public boolean isFull() {
        return top == MaxSize - 1;
    }
    //判断栈 是否是空的
    public boolean isempty() {
        return top == -1;
    }
    //将数据压入栈
    public void push(int data) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = data;
    }
    //    将数据取出栈
    public int pop() {
        if (isempty()) {
            throw new RuntimeException("栈是空的 无法取出");
        }
        int value = stack[top];
        top--;
        return value;
    }
    //遍历栈 遍历的时候需要从栈顶开始显示数据
    public void list() {
        if (isempty()) {
            System.out.println("栈是空的");
        }
        //   从栈顶开始输出 其实就是倒序的输出数组
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
    /* 返回运算符的优先级 这个规则我们可以自己来设定 优先级使用数字来表示
     * 数字越大优先级约高
     * */
    public int priotrity(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;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '/':
                res = num2 / num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            default:
                break;
        }
        return res;
    }
}

public static void main(String[] args) {
        //定义逆波兰表达式
        //    测试
        String suffixExpression = "3 4 + 5 * 6 -";
        //    思路
        //    1. 先将 3 4 + 5 * 6 - 方法哦 ArrayList中
        //    2. 将 Arraylist 传递一个方法 遍历ArrayList 配合栈完成计算
        List<String> list = getListString(suffixExpression);
        System.out.println("rpnlist = " + list);
        int res = calculate(list);
        System.out.println("计算的结果是 = " + res);
    }
    /**
     * @author 冷环渊 Doomwatcher
     * @context: 将一个逆波兰表达式的数据和运算符 依次放入Arraylist中
     * @date: 2021/12/25 18:09
     * @param suffixExpression
     * @return: java.util.List<java.lang.String> 将分割好的字符List 返回
     */
    public static List<String> getListString(String suffixExpression) {
        //  分割字符串 将后缀表达式的每一个字符取出
        String[] split = suffixExpression.split(" ");
        // 我们用list 来存储分割出来的表达式，这样之后我们就需要遍历即可
        List<String> list = new ArrayList<>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }
/**
     * @author 冷环渊 Doomwatcher
     * @context: 这个方法就是 逆波兰表达式的运算处理方法
     *  * 实现思路 : 我们以 （3+4）*4-6 对应的后缀表达式 => 3 4 + 5 * 6 -
     *  * 1） 从左至右扫描，将3和4压入栈
     *  * 2） 遇到+运算符号 因此弹出 4 和 3 （4为栈顶元素 3 为次顶元素） 计算出3+4的值，将计算的结果加入栈
     *  * 3） 将5 入栈
     *  * 4） 接下来将 * 是运算符 弹出 5和7 计算出 7*5  = 35 将结果入栈
     *  * 5） 将6 入栈
     * @date: 2021/12/25 18:14
     * @param ls
     * @return: int 返回的是一个运算结果
     */
    public static int calculate(List<String> ls) {
        //创建栈 只需要一个栈即可
        Stack<String> stack = new Stack<>();
        //    遍历处理
        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 ("+".equals(item)) {
                    res = num1 + num2;
                } else if ("-".equals(item)) {
                    res = num1 - num2;
                } else if ("*".equals(item)) {
                    res = num1 * num2;
                } else if ("/".equals(item)) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //    把 res 入栈
                stack.push("" + res);
            }
        }
        //最后留在stack 中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }

package com.hyc.DataStructure.Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
 * @projectName: DataStructure
 * @package: com.hyc.DataStructure.Stack
 * @className: PolandExpression
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * 实现思路 : 我们以 （3+4）*4-6 对应的后缀表达式 => 3 4 + 5 * 6 -
 * 1） 从左至右扫描，将3和4压入栈
 * 2） 遇到+运算符号 因此弹出 4 和 3 （4为栈顶元素 3 为次顶元素） 计算出3+4的值，将计算的结果加入栈
 * 3） 将5 入栈
 * 4） 接下来将 * 是运算符 弹出 5和7 计算出 7*5  = 35 将结果入栈
 * 5） 将6 入栈
 * 最后 是 - 运算符 计算出 35-6  = 29 由此得出最后的结果
 *
 * 使用技术 这里我们用 java给我们提供的 Stack 和 ArrayList组合来实现计算器
 * @date: 2021/12/25 18:00
 * @version: 1.0
 */
public class PolandExpression {
    public static void main(String[] args) {
        //定义中缀表达式 ，转成后置表达式之后运算
        String expression = "1+((2+3)*4)-5";
        //拆成链表
        List<String> infixExpressionList = toinfixExpression(expression);
        System.out.println("中缀表达式对应的list=" + infixExpressionList);
        List<String> suffixexpression = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的List" + suffixexpression);
        System.out.printf("expression=%d", calculate(suffixexpression));
        //定义逆波兰表达式
        //    测试
        String suffixExpression = "3 4 + 5 * 6 -";
        //    思路
        //    1. 先将 3 4 + 5 * 6 - 方法哦 ArrayList中
        //    2. 将 Arraylist 传递一个方法 遍历ArrayList 配合栈完成计算
        List<String> list = getListString(suffixExpression);
        System.out.println("rpnlist = " + list);
        int res = calculate(list);
        System.out.println("计算的结果是 = " + res);
    }
    /**
     * @author 冷环渊 Doomwatcher
     * @context: 将 Arraylist[1,+,(,(,2,+,3,),*,4,),-,5]  转化成  Arraylist[1,2,3,+,4,*,5,-]
     *  转换思路：
     * 1. 初始化两个栈 元素安抚栈 s1 和存储中间结果的栈2
     * 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中的元素并且输出，结果逆序就是中缀表达式对应的后缀的表达式
     *
     * @date: 2021/12/27 17:48
     * @param
     * @return: java.util.List<java.lang.String>
     */
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //    定义两个栈
        /*符号栈*/
        Stack<String> s1 = new Stack<>();
        /* S2 思路说明
         * 这里我们使用栈 在转换过程中我们不需要pop操作，而且这个s2 之后我们需要逆序输出操作很麻烦
         * 于是这里使用List来当作 s2 的数据存储结构
         * */
        List<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();
            } else {
                /* 当 item 优先级小于等于s1 栈顶运算符的时候 将s1栈顶的运算符淡出并且加入到s2 中，再次重复思路中的第四个环节，与s1中的新栈顶运算符比较
                 *问题 我们缺少一个比较优先级高低的方法
                 * */
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //    之后将 itea 压入栈
                s1.push(item);
            }
        }
        //    将s1中剩余的运算符一次弹出加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }
        //    注意应为存放的是list 这里我们顺序不需要改变 直接输出就是对应的后缀表达式
        return s2;
    }
    /**
     * @author 冷环渊 Doomwatcher
     * @context: 将中缀表达式 转换成对应的list
     * @date: 2021/12/27 17:32
     * @param s
     * @return: java.util.List<java.lang.String>
     */
    public static List<String> toinfixExpression(String s) {
        /*定义一个List 存放中缀表达式的对应内容*/
        List<String> ls = new ArrayList<>();
        //定义一个指针 用于遍历 中缀表达式的字符串
        int i = 0;
        // 用于拼接字符串
        String str;
        //用于存放遍历的字符
        char c;
        do {
            //   如果c是一个非数字 那么我们需要加入到 ls 中去 ，这里的判断条件是 ASCLL值
            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;
    }
    /**
     * @author 冷环渊 Doomwatcher
     * @context: 将一个逆波兰表达式的数据和运算符 依次放入Arraylist中
     * @date: 2021/12/25 18:09
     * @param suffixExpression
     * @return: java.util.List<java.lang.String> 将分割好的字符List 返回
     */
    public static List<String> getListString(String suffixExpression) {
        //  分割字符串 将后缀表达式的每一个字符取出
        String[] split = suffixExpression.split(" ");
        // 我们用list 来存储分割出来的表达式，这样之后我们就需要遍历即可
        List<String> list = new ArrayList<>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }
    /**
     * @author 冷环渊 Doomwatcher
     * @context: 这个方法就是 逆波兰表达式的运算处理方法
     *  * 实现思路 : 我们以 （3+4）*4-6 对应的后缀表达式 => 3 4 + 5 * 6 -
     *  * 1） 从左至右扫描，将3和4压入栈
     *  * 2） 遇到+运算符号 因此弹出 4 和 3 （4为栈顶元素 3 为次顶元素） 计算出3+4的值，将计算的结果加入栈
     *  * 3） 将5 入栈
     *  * 4） 接下来将 * 是运算符 弹出 5和7 计算出 7*5  = 35 将结果入栈
     *  * 5） 将6 入栈
     * @date: 2021/12/25 18:14
     * @param ls
     * @return: int 返回的是一个运算结果
     */
    public static int calculate(List<String> ls) {
        //创建栈 只需要一个栈即可
        Stack<String> stack = new Stack<>();
        //    遍历处理
        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 ("+".equals(item)) {
                    res = num1 + num2;
                } else if ("-".equals(item)) {
                    res = num1 - num2;
                } else if ("*".equals(item)) {
                    res = num1 * num2;
                } else if ("/".equals(item)) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                //    把 res 入栈
                stack.push("" + res);
            }
        }
        //最后留在stack 中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }
}
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 operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }
}

public static void quickSort(int[] arr, int left, int right) {
        //  left index
        int l = left;
        int r = right;
        //    pivot 中轴值
        int pivot = arr[(left + right) / 2];
        //临时变量
        int temp = 0;
        //    while 循环的目的是比比中轴的pivot值小的放在左边
        //    比pivot 值大的放在右边
        while (l < r) {
            //    在pivot的左边一直寻找 找到大于等于pivot 的值才退出
            while (arr[l] < pivot) {
                l += 1;
            }
            //    在pivot的右边一直寻找 找到小于等于pivot 的值才退出
            while (arr[r] > pivot) {
                r -= 1;
            }
            //    如果 l>=r说明pivot的左右两个值已经按照左边全都是小于等于pivot，右边去哪不是大于等于pivot排列好了
            if (l >= r) {
                break;
            }
            //    交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //    如果交换玩发现这个arr[l]==pivot值 相等r--前移
            if (arr[l] == pivot) {
                r -= 1;
            }
            //如果交换玩发现 arr[r] == pivot值 相等l++ 后移
            if (arr[r] == pivot) {
                l += 1;
            }
        }
        //    如果l==r 必须是 l++ r-- 否则会出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }
        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }
        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
    }

package com.hyc.DataStructure.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class MergetSort {
    public static void main(String[] args) {
        int arr[] = {8, 4, 5, 7, 1, 3, 6, 2}; //
        //测试快排的执行速度
        // 创建要给80000个的随机的数组
        //int[] arr = new int[8000000];
        //for (int i = 0; i < 8000000; i++) {
        //    arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
        //}
        System.out.println("排序前");
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);
        int temp[] = new int[arr.length]; //归并排序需要一个额外空间
        mergeSort(arr, 0, arr.length - 1, temp);
        Arrays.toString(arr);
        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间是=" + date2Str);
        //System.out.println("归并排序后=" + Arrays.toString(arr));
    }
    //分+合方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2; //中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);
        }
    }
    //合并的方法
    /**
     *
     * @param arr 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; // 初始化i, 左边有序序列的初始索引
        int j = mid + 1; //初始化j, 右边有序序列的初始索引
        int t = 0; // 指向temp数组的当前索引
        //(一)
        //先把左右两边(有序)的数据按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= right) {//继续
            //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前元素，填充到 temp数组
            //然后 t++, i++
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else { //反之,将右边有序序列的当前元素，填充到temp数组
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        //(二)
        //把有剩余数据的一边的数据依次全部填充到temp
        while (i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }
        //(三)
        //将temp数组的元素拷贝到arr
        //注意，并不是每次都拷贝所有
        t = 0;
        int tempLeft = left; //
        //第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
        //最后一次 tempLeft = 0  right = 7
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }
}

package com.hyc.DataStructure.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class RadixSort {
    public static void main(String[] args) {
        int arr[] = {53, 3, 542, 748, 14, 214};
        // 80000000 * 11 * 4 / 1024 / 1024 / 1024 =3.3G
//    int[] arr = new int[8000000];
//    for (int i = 0; i < 8000000; i++) {
//      arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
//    }
        System.out.println("排序前");
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);
        radixSort(arr);
        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间是=" + date2Str);
        System.out.println("基数排序后 " + Arrays.toString(arr));
    }
    //基数排序方法
    public static void radixSort(int[] arr) {
        //根据前面的推导过程，我们可以得到最终的基数排序代码
        //1. 得到数组中最大的数的位数
        int max = arr[0]; //假设第一数就是最大数
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();
        //定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
        //说明
        //1. 二维数组包含10个一维数组
        //2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
        //3. 名明确，基数排序是使用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];
        //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
        //可以这里理解
        //比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数
        int[] bucketElementCounts = new int[10];
        //这里我们使用循环将代码处理
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digitOfElement = arr[j] / n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
            int index = 0;
            //遍历每一桶，并将桶中是数据，放入到原数组
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[k] != 0) {
                    //循环该桶即第k个桶(即第k个一维数组), 放入
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        //取出元素放入到arr
                        arr[index++] = bucket[k][l];
                    }
                }
                //第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
                bucketElementCounts[k] = 0;
            }
            //System.out.println("第"+(i+1)+"轮，对个位的排序处理 arr =" + Arrays.toString(arr));
        }
    
    /*
    
    //第1轮(针对每个元素的个位进行排序处理)
    for(int j = 0; j < arr.length; j++) {
      //取出每个元素的个位的值
      int digitOfElement = arr[j] / 1 % 10;
      //放入到对应的桶中
      bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
      bucketElementCounts[digitOfElement]++;
    }
    //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
    int index = 0;
    //遍历每一桶，并将桶中是数据，放入到原数组
    for(int k = 0; k < bucketElementCounts.length; k++) {
      //如果桶中，有数据，我们才放入到原数组
      if(bucketElementCounts[k] != 0) {
        //循环该桶即第k个桶(即第k个一维数组), 放入
        for(int l = 0; l < bucketElementCounts[k]; l++) {
          //取出元素放入到arr
          arr[index++] = bucket[k][l];
        }
      }
      //第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
      bucketElementCounts[k] = 0;
      
    }
    System.out.println("第1轮，对个位的排序处理 arr =" + Arrays.toString(arr));
    
    
    //==========================================
    
    //第2轮(针对每个元素的十位进行排序处理)
    for (int j = 0; j < arr.length; j++) {
      // 取出每个元素的十位的值
      int digitOfElement = arr[j] / 10  % 10; //748 / 10 => 74 % 10 => 4
      // 放入到对应的桶中
      bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
      bucketElementCounts[digitOfElement]++;
    }
    // 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
    index = 0;
    // 遍历每一桶，并将桶中是数据，放入到原数组
    for (int k = 0; k < bucketElementCounts.length; k++) {
      // 如果桶中，有数据，我们才放入到原数组
      if (bucketElementCounts[k] != 0) {
        // 循环该桶即第k个桶(即第k个一维数组), 放入
        for (int l = 0; l < bucketElementCounts[k]; l++) {
          // 取出元素放入到arr
          arr[index++] = bucket[k][l];
        }
      }
      //第2轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
      bucketElementCounts[k] = 0;
    }
    System.out.println("第2轮，对个位的排序处理 arr =" + Arrays.toString(arr));
    
    
    //第3轮(针对每个元素的百位进行排序处理)
    for (int j = 0; j < arr.length; j++) {
      // 取出每个元素的百位的值
      int digitOfElement = arr[j] / 100 % 10; // 748 / 100 => 7 % 10 = 7
      // 放入到对应的桶中
      bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
      bucketElementCounts[digitOfElement]++;
    }
    // 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
    index = 0;
    // 遍历每一桶，并将桶中是数据，放入到原数组
    for (int k = 0; k < bucketElementCounts.length; k++) {
      // 如果桶中，有数据，我们才放入到原数组
      if (bucketElementCounts[k] != 0) {
        // 循环该桶即第k个桶(即第k个一维数组), 放入
        for (int l = 0; l < bucketElementCounts[k]; l++) {
          // 取出元素放入到arr
          arr[index++] = bucket[k][l];
        }
      }
      //第3轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
      bucketElementCounts[k] = 0;
    }
    System.out.println("第3轮，对个位的排序处理 arr =" + Arrays.toString(arr)); */
    }
}

8000000 * 11 * 4 / 1024 / 1024 / 1024 =1G