动态数组栈的应用----进制转换，括号匹配

1. 通过栈将十进制数转成十六进制数

十进制数转十六进制数即将十进制数一致除16，每次去余数，直至除16的结果0，余数倒序排列即可。如图：

 

//将十进制数转换十六进制数
public class DecToHex {
    public static void main(String[] args) {
        int decNumber = 654321;
        ArrayStack<String> stack = new ArrayStack<>();
        while (decNumber != 0){
            int yu = decNumber % 16;
            if(yu < 10){
                stack.push(yu + "");
            }else{
                stack.push((char) (yu - 10 + 'A') + "");
            }
            decNumber /= 16;
        }
        StringBuilder str = new StringBuilder();
        while (!stack.isEmpty()){
            str.append(stack.pop());
        }
        System.out.println(str.toString());
    }
}

2. 通过栈将十六进制数转成十进制数

十六进制数转十进制数即十六进制数的每一位都要乘十六的每一位对应的幂数次幂，最后将其相加即可。如图：

//将十六进制数转换成十进制数
//1*16^0 + F*16^1 + B*16^2 + F*16^3 + 9*16^4
public class HexToDec {
    public static void main(String[] args) {
        String str = "9FBF1";
        ArrayStack<Character> stack = new ArrayStack<>();
        for(int i = 0; i < str.length(); i++){
            stack.push(str.charAt(i));
        }
        int sum = 0;
        int mi = 0;
        while (!stack.isEmpty()){
            int a = stack.pop();
            sum += getNumber(a) * Math.pow(16, mi);
            mi++;
        }
        System.out.println(sum);
    }

    //获取字符串的十六进制数对应的int型的数字
    private static int getNumber(int a) {
        if(!((a > '0' && a < '9') || (a > 'A' && a < 'F'))){
            throw new IllegalArgumentException("wrong char!");
        }else{
            if(a > '0' && a < '9'){
                return a - '0'; //将字符0-9转成数字0-9
            }else{
                return a - 'A' + 10; //将字符A-F转成10-15
            }
        }
    }
}

 

3. 括号匹配

括号匹配即判断由各种括号组成的字符串中的每一个括号是否匹配，括号如：< >, [ ], { }, ( )。

//判断括号字符串是否能匹配上每一个括号字符
public class MatchBracket {
    public static void main(String[] args) {
        String matchStr = "({{[<>]}}){}[]()";
        solution01(matchStr);
        solution02(matchStr);
    }

    //方式1 通过ascii码来判断括号是否匹配
    private static void solution01(String matchStr) {
        ArrayStack<Character> stack = new ArrayStack<>();
        for(int i = 0; i < matchStr.length(); i++){
            char c = matchStr.charAt(i);
            if(stack.isEmpty()){
                stack.push(c);
            }else{
                char top = stack.peek();
                if(top - c == -1 || top - c == -2){
                    stack.pop();
                }else {
                    stack.push(c);
                }
            }
        }
        System.out.println(stack.isEmpty());
    }

    //方式2 通过HashMap来判断括号是否匹配 将遍历的到字符当成key，判断HashMap中是否有与之对应的value即可
    private static void solution02(String matchStr) {
        ArrayStack<Character> stack = new ArrayStack<>();
        HashMap<Character, Character> map = new HashMap<>();
        map.put('[', ']');
        map.put('{', '}');
        map.put('<', '>');
        map.put('(', ')');
        for(int i = 0; i < matchStr.length(); i++) {
            char c = matchStr.charAt(i);
            if(stack.isEmpty()){
                stack.push(c);
            }else {
                char top = stack.peek();
                if(map.containsKey(top) && c == map.get(top)){
                    stack.pop();
                }else{
                    stack.push(c);
                }
            }
        }
        System.out.println(stack.isEmpty());
    }
}