栈经典题目 lee20有效的括号。 lee150 逆波兰表达式。lee71简化unix路径

lee20 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true

思路用stack

左括号入栈，如果遇到右括号判断是否匹配
最后如果stack为空，则才成功
所以中间判断的是为false 的情况

class Solution {
    public boolean isValid(String s) {
        Stack <Character> stack = new Stack<>();
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            if(c=='{' || c=='(' ||c=='['){
                stack.push(c);
            }
            else {
                if(stack.size()==0)
                    return false;
                char t=stack.pop();
                
                if(t=='[' && c!=']')
                    return false;
                else if(t=='{' && c!='}')
                    return false;
                else if(t=='(' && c!=')')
                    return false;               
            }
        }
        return stack.isEmpty();
    }
}

lee150 逆波兰表达式

根据逆波兰表示法，求表达式的值。
有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：
输入: [“2”, “1”, “+”, “3”, “"]
输出: 9
解释: ((2 + 1) * 3) = 9
示例 2：
输入: [“4”, “13”, “5”, “/”, “+”]
输出: 6
解释: (4 + (13 / 5)) = 6
示例 3：
输入: [“10”, “6”, “9”, “3”, “+”, “-11”, "”, “/”, “*”, “17”, “+”, “5”, “+”]
输出: 22
解释:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

思考

数字放到栈里，如果遇到运算符 ，就取出两个栈顶元素，进行相应运算
**然后再吧得数放回栈中，**继续

以下代码没找到错误

class Solution {
    public int evalRPN(String[] tokens) {
        if (tokens.length <= 1) return Integer.parseInt(tokens[0]);
        Stack<Integer> elements = new Stack<>();
        int res = 0;
        int num = 0;
        int num2 = 0;
        for (int i = 0; i < tokens.length; i++) {
            if (tokens[i].equals("+") || tokens[i].equals("/") || tokens[i].equals("*") || tokens[i].equals("-")) { 
                    num = elements.pop(); 
                    num2 = elements.pop();
                    if (tokens[i].equals("+")) res = num2 + num;
                    if (tokens[i].equals("-")) res = num2 - num;
                    if (tokens[i].equals("*")) res = num2 * num;
                    if (tokens[i].equals("/")) res = num2 / num;
                    elements.push(res);
            } else elements.push(Integer.parseInt(tokens[i]));
        }
        return res;
    }
}

/*
class Solution {
    public int evalRPN(String[] tokens) {
        if(tokens.length<=1)  return Integer.parseInt(tokens[0]);
        Stack<Integer> stack=new Stack<>();
        int res=0;
        int num1=0,num2=0;
        for(int i=0;i<tokens.length;i++){
            if(tokens[i].equals("+")||tokens[i].equals("-")||tokens[i].equals("*")||tokens[i].equals("/")){
                num1=stack.pop();
                num2=stack.pop();
                if(tokens[i].equals("+")) res=num1+num2;
                if(tokens[i].equals("-")) res=num1-num2;
                if(tokens[i].equals("*")) res=num1*num2;
                if(tokens[i].equals("/")) res=num1/num2;
                stack.push(res);//非常重要，勿忘
            }
            else
                stack.push(Integer.parseInt(tokens[i]));

        }
        return res;
    }
}*/

Integer的parseInt和valueOf的区别

先来看一下下面这段代码
String s = “1”;
System.out.println(Integer.valueOf(s));
System.out.println(Integer.parseInt(s));
输出结果是什么？没错，一样都是1。两个方法都可以把数字类型字符串转成int类型整数，但是这两个方法还是有一点区别的，valueOf(String s)方法调用了parseInt(String s, int radix)方法，而parseInt(String s, int radix)方法返回值是一个int类型的值，之后又调用了valueOf(int i)方法将int进行了装箱返回包装类型Integer。

所以如果你不需要返回包装类型，可以直接调用parseInt(String s)方法，效率更高。

lee71简化路径

以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径

请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。

示例 1：
输入："/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。
示例 2：
输入："/…/"
输出："/"
解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。
示例 3：
输入："/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：
输入："/a/./b/…/…/c/"
输出："/c"
示例 5：
输入："/a/…/…/b/…/c//.//"
输出："/c"
示例 6：
输入："/a//bc/d//././/…"
输出："/a/b/c"

1.此题主要考察的是栈,所以定义一个辅助栈;
2.先把字符串以"/“为分隔符分割成数组,
此时数组有** “路径”、”"、"."、"…" ** 这四种情况;
3.遍历数组,当s[i].equals("…")并且栈不空时pop,当!s[i].equals("") && !s[i].equals(".") && !s[i].equals("…"),即s[i]是路径入栈;
4.栈空,返回"/",栈非空,用StringBuffer做一个连接返回即可;
5完结。

 public String simplifyPath(String path) {
        String[] s = path.split("/");
        Stack<String> stack = new Stack<>();
        
        for (int i = 0; i < s.length; i++) {
            if (!stack.isEmpty() && s[i].equals(".."))
                stack.pop();
            else if (!s[i].equals("") && !s[i].equals(".") && !s[i].equals(".."))
                stack.push(s[i]);
        }
        if (stack.isEmpty())
            return "/";

        StringBuffer res = new StringBuffer();
        for (int i = 0; i < stack.size(); i++) {
            res.append("/" + stack.get(i));
        }
        return res.toString();
    }