栈(stack)、递归（八皇后问题）、排序算法分类，时间和空间复杂度简介

import java.util.Stack;

public class Calculator {
    public static void main(String[] args) {
        //获取一个和栈相关计算操作的对象
        AboutStack stack = new AboutStack();
        String calcu = "2000*1+3*2-4";
        //将字符串转换为一个char数组
        char[] chars = calcu.toCharArray();

        //循环数组，判断字符为数字还是操作符，进行添加和计算
        for (char ch:chars) {
            if ('0' <= ch && ch <= '9') {
                //添加数字到数字栈中
                stack.addToNumStack(ch);
            }else {
                //添加符号到符号栈中
                stack.addToSymbolStack(ch);
            }
        }
        //进行最后结果的计算和输出
        System.out.println(stack.calculator(stack.numStack.pop(),stack.numStack.pop(),stack.symbolsStack.pop()));

    }

}
class AboutStack{
    public Stack<Integer> numStack;
    public Stack<Character> symbolsStack;
    public Boolean next = false;

    public AboutStack() {
        //初始化数字栈和字符栈
        numStack = new Stack<>();
        symbolsStack = new Stack<>();
    }
    //添加数到数值栈中
    public void addToNumStack(char ch){
        if (numStack.isEmpty()) {//判断当前栈是否为空，如果为空就直接将数字加入到数字栈中
            numStack.push(Integer.parseInt(String.valueOf(ch)));
            next = true;
            return;
        }
        if (next ){//判断是否连续的两个CHAR字符都是数字，如果是，就表示是多位的数字，得到多位数字再放入到栈中
            int num = numStack.pop();
            String temp = num +""+String.valueOf(ch);//将上一个字符和现在的字符拼接成一个字符串，再将字符串转换为数字存放在数值栈中
            numStack.push(Integer.parseInt(temp));
            next = true;
        }else {
            //表示上一个存放的是字符，所以这次的数字直接放入到数字栈中
            numStack.push(Integer.parseInt(String.valueOf(ch)));
            next = true;
        }
    }
    //添加符号到符号栈中
    public void  addToSymbolStack(char ch){
        //如果符号栈为空，直接将符号放入到栈中
        if (symbolsStack.isEmpty()) {
            symbolsStack.push(ch);
            next = false;
            return;
        }
        //如果该符号的优先级小于或者等于上一个符号，就先计算上一个符号优先级较大的，、
        // 再将计算结果放入到数值栈，将该符号放入到栈中
        if (priority(ch) <= priority(symbolsStack.peek())) {
            numStack.push(calculator(numStack.pop(), numStack.pop(), symbolsStack.pop()));
            addToSymbolStack(ch);
            //            symbolsStack.push(ch);
            next = false;
        }else{
            symbolsStack.push(ch);
            next = false;
        }

    }
    //判断符号的优先级
    public int priority(char oper){
        if (oper == '*' || oper == '/') {
            return 2;
        }
        if (oper == '+' || oper == '-') {
            return 1;
        }else {
            return -1;
        }
    }

    //根据数值和符号计算出两个数的值
    public int calculator(int num1,int num2,char ch){
        int res = 0; // res 用于存放计算的结果
        switch (ch) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;// 注意顺序
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }


}

package com.zjl.recursion;

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

        Queen8 queen8 = new Queen8();
        queen8.check(0);
        System.out.println("符合八皇后的位置个数一共有："+queen8.count);
    }
}

class Queen8 {
    //定义所有坐标的长度，表示一共8个皇后
    private static final int max = 8;
    //确定一个数组，表示8个皇后在每行的第几个位置
    private int[] arr = new int[max];
    //统计一共有多少个解
    public static int count = 0;

    public void check(int n) {
        //判断是否到达最后一个皇后，如果是就将该数组输出
        if (n >= maX) {
            Print();
            return;
        }
        //如果不是，就将该皇后从该列的的第一个位置开始放，直到找到适合它的位置
        for (int i = 0; i < max; i++) {
                arr[n] = i;//将该皇后放在该列上
            if (Judge(n)) {//判断该皇后的位置是否正确，如果返回结果是正确的，那就继续放下一个皇后
                check(n + 1);
            }
        }
    }

    //判断该皇后放置的位置是否满足八皇后的要求
    public Boolean Judge(int n) {
        /**
         * 1、arr[i] == arr[n]判断该皇后的位置是否和她前面的皇后的位置是在同一列，在就返回false
         * 2、Math.abs(i - n) == Math.abs(arr[i] - arr[n])判断该皇后的对角线上（斜线）有没有皇后，有就返回false
         * 3、如果返回结果为true就表示该位置可以放该皇后，不用判断不同皇后是否在同一行
         * 因为每一行都只安排了一个皇后放置
         */
        for (int i = 0; i < n; i++) {
            if (arr[i] == arr[n] || Math.abs(i - n) == Math.abs(arr[i] - arr[n])) {
                return false;
            }
        }
        return true;
    }

    //输出一个完整的可以完成8皇后的数组
    public void Print() {
        count++;//进行输出操作，说明就有一个数组满足8皇后的要求，对统计的和加一
        for (int i = 0; i < max; i++) {
            System.out.printf("%d ", arr[i]);
        }
        System.out.println();//每一个数组输出后都进行换行操作
    }

}