Basic Calculator

Implement a basic calculator to evaluate a simple expression string.

The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .

You may assume that the given expression is always valid.

Some examples:

"1 + 1" = 2
" 2-1 + 2 " = 3
"(1+(4+5+2)-3)+(6+8)" = 23

Note: Do not use the eval built-in library function.

题目中只有+ – ( )。遍历字符串，对于每个字符c：

1. 如果是数字，则一直遍历到非数字字符，把数字找出，并与结果相加
2. 如果是+-符号，将sign设置成对应的值
3. 如果是(，将rt和sign压入栈中，重置rt和sign
4. 如果是)，将sign和rt弹出栈，并计算结果

    public int calculate(String s) {

        if (s == null || s.length() == 0) {
            return 0;
        }

        Stack<Integer> stack = new Stack<Integer>();

        int sign = 1;// 符号位，1表示+，-1表示-
        int rt = 0;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (Character.isDigit(c)) {
                int val = c - '0';
                // 将数字取出
                while (i + 1 < s.length() && Character.isDigit(s.charAt(i + 1))) {
                    val = val * 10 + s.charAt(++i) - '0';
                }
                rt += sign * val;
            } else if (c == '-') {
                sign = -1;
            } else if (c == '+') {
                sign = 1;
            } else if (c == '(') {
                // 按照数字、符号的顺序，压入栈
                stack.push(rt);
                stack.push(sign);
                rt = 0;
                sign = 1;
            } else if (c == ')') {
                rt = rt * stack.pop() + stack.pop();
                sign = 1;
            }
        }

        return rt;

    }

Basic Calculator II

Implement a basic calculator to evaluate a simple expression string.

The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.

You may assume that the given expression is always valid.

Some examples:

"3+2*2" = 7
" 3/2 " = 1
" 3+5 / 2 " = 5

Note: Do not use the eval built-in library function.

Credits: 
Special thanks to @ts for adding this problem and creating all test cases.

分两次遍历，第一次遍历时，遇到乘除符号就计算；第二次遍历，计算加减符号。

    public int calculate(String s) {

        if (s == null || s.length() == 0) {
            return 0;
        }

        Stack<Integer> stack = new Stack<Integer>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (Character.isDigit(c)) {
                int val = c - '0';
                // 将数字取出
                while (i + 1 < s.length() && Character.isDigit(s.charAt(i + 1))) {
                    val = val * 10 + s.charAt(++i) - '0';
                }
                // 栈顶是 * / 运算符，计算
                if (!stack.isEmpty()
                        && (stack.peek() == 2 || stack.peek() == 3)) {
                    int sign = stack.pop();
                    int op = stack.pop();
                    int rt = 0;
                    if (sign == 2) {
                        rt = op * val;
                    } else {
                        rt = op / val;
                    }
                    stack.push(rt);
                } else {
                    stack.push(val);
                }
            } else if (c == ' ') {
                continue;
            } else {
                switch (c) {
                case '+':
                    stack.push(0);
                    break;
                case '-':
                    stack.push(1);
                    break;
                case '*':
                    stack.push(2);
                    break;
                case '/':
                    stack.push(3);
                    break;

                }
            }
        }

        if (stack.isEmpty()) {
            return 0;
        }

        // 因为要从左向右计算，所以要reverse
        Collections.reverse(stack);

        // 计算+-
        int rt = stack.pop();
        while (!stack.isEmpty()) {
            int sign = stack.pop();
            int op = stack.pop();
            if (sign == 0) {
                rt += op;
            } else {
                rt -= op;
            }
        }

        return rt;
    }

Evaluate Reverse Polish Notation

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Some examples:

["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

这道题是给定了合法的逆波兰表达式，要求根据给定的逆波兰表达式，求出最终结果。

只需要定义一个stack，如果是+, -, *, /四个运算符，就取出栈顶的两个数，进行相应操作。之后将计算得到的结果压入栈中。如果是数字，就直接入栈。

最终stack只剩下一个元素，这个元素就是逆波兰表达式的值。

逆波兰表达式

逆波兰表达式又叫做后缀表达式。下面是一些例子：

正常的表达式 逆波兰表达式

a+b —> a,b,+ 
a+(b-c) —> a,b,c,-,+ 
a+(b-c)_d —> a,b,c,-,d,_,+ 
a+d*(b-c)—>a,d,b,c,-,*,+ 
a=1+3 —> a=1,3 +

优势

它的优势在于只用两种简单操作，入栈和出栈就可以搞定任何普通表达式的运算。其运算方式如下：

如果当前字符为变量或者为数字，则压栈，如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的就是结果。

    public int evalRPN(String[] tokens) {

        Stack<Integer> stack = new Stack<Integer>();

        for (String s : tokens) {

            if ("*".equals(s)) {
                int n2 = stack.pop();
                int n1 = stack.pop();

                stack.push(n1 * n2);
            } else if ("/".equals(s)) {
                int n2 = stack.pop();
                int n1 = stack.pop();

                stack.push(n1 / n2);
            } else if ("+".equals(s)) {
                int n2 = stack.pop();
                int n1 = stack.pop();

                stack.push(n1 + n2);
            } else if ("-".equals(s)) {
                int n2 = stack.pop();
                int n1 = stack.pop();

                stack.push(n1 - n2);
            } else {
                stack.push(Integer.valueOf(s));
            }

        }

        return stack.pop();
    }

Implement Queue using Stacks

Implement the following operations of a queue using stacks.

• push(x) – Push element x to the back of queue.
• pop() – Removes the element from in front of queue.
• peek() – Get the front element.
• empty() – Return whether the queue is empty.

Notes:

• You must use only standard operations of a stack – which means only push to top, peek/pop from top, size, and is empty operations are valid.
• Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
• You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

非常经典的题目，定义两个栈模拟队列。

1. push向stack1
2. pop从stack2，如果stack2为空，先将stack1的元素放入stack2

    class MyQueue {

        Stack<Integer> stack1 = new Stack<Integer>();
        Stack<Integer> stack2 = new Stack<Integer>();

        // Push element x to the back of queue.
        public void push(int x) {
            stack1.push(x);
        }

        // Removes the element from in front of queue.
        public void pop() {
            if (stack2.isEmpty()) {
                if (stack1.isEmpty()) {
                    throw new IllegalStateException();
                }
                while (!stack1.isEmpty()) {
                    stack2.push(stack1.pop());
                }
            }
            stack2.pop();
        }

        // Get the front element.
        public int peek() {
            if (stack2.isEmpty()) {
                if (stack1.isEmpty()) {
                    throw new IllegalStateException();
                }
                while (!stack1.isEmpty()) {
                    stack2.push(stack1.pop());
                }
            }
            return stack2.peek();
        }

        // Return whether the queue is empty.
        public boolean empty() {

            if (stack1.isEmpty() && stack2.isEmpty()) {
                return true;
            }

            return false;
        }
    }

Implement Stack using Queues

Implement the following operations of a stack using queues.

• push(x) – Push element x onto stack.
• pop() – Removes the element on top of the stack.
• top() – Get the top element.
• empty() – Return whether the stack is empty.

Notes:

• You must use only standard operations of a queue – which means only push to back, peek/pop from front, size, and is empty operations are valid.
• Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
• You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

Update (2015-06-11):
The class name of the Java function had been updated to MyStack instead of Stack.

Credits:
Special thanks to @jianchao.li.fighter for adding this problem and all test cases.

非常经典的题目，定义两个队列模拟栈的操作。总保持一个队列为空：

1. push就插入到非空的队列中
2. pop就把非空队列元素，依次放到另一个空队列中，只是最后一个元素弹出

    class MyStack {

        Queue<Integer> q1 = new LinkedList<Integer>();
        Queue<Integer> q2 = new LinkedList<Integer>();

        // Push element x onto stack.
        public void push(int x) {
            if (q1.isEmpty() && q2.isEmpty()) {
                q1.add(x);
            } else if (!q1.isEmpty()) {
                q1.add(x);
            } else {
                q2.add(x);
            }
        }

        // Removes the element on top of the stack.
        public void pop() {

            if (empty()) {
                throw new IllegalStateException();
            }

            // q1、q2必有一个为空
            if (q2.isEmpty()) {
                while (!q1.isEmpty()) {
                    int x = q1.remove();
                    if (!q1.isEmpty()) {
                        q2.add(x);
                    }
                }
            } else if (q1.isEmpty()) {
                while (!q2.isEmpty()) {
                    int x = q2.remove();
                    if (!q2.isEmpty()) {
                        q1.add(x);
                    }
                }
            }
        }

        // Get the top element.
        public int top() {

            if (empty()) {
                throw new IllegalStateException();
            }

            int x = 0;

            // q1、q2必有一个为空
            if (q2.isEmpty()) {
                while (!q1.isEmpty()) {
                    x = q1.remove();
                    q2.add(x);
                }
            } else if (q1.isEmpty()) {
                while (!q2.isEmpty()) {
                    x = q2.remove();
                    q1.add(x);
                }
            }

            return x;
        }

        // Return whether the stack is empty.
        public boolean empty() {

            if (q1.isEmpty() && q2.isEmpty()) {
                return true;
            }

            return false;
        }
    }

Min Stack

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

• push(x) – Push element x onto stack.
• pop() – Removes the element on top of the stack.
• top() – Get the top element.
• getMin() – Retrieve the minimum element in the stack.

本题是一个栈的操作，但是要求getMin()在O(1)的时间复杂度。

考虑使用另一个辅助栈，用来存储[0..i]的最小值。

    class MinStack {

        Stack<Integer> stack = new Stack<Integer>();
        Stack<Integer> min = new Stack<Integer>();

        public void push(int x) {
            if (stack.isEmpty()) {
                stack.push(x);
                min.push(x);
            } else {
                stack.push(x);
                min.push(Math.min(stack.peek(), min.peek()));
            }
        }

        public void pop() {
            if (!stack.isEmpty()) {
                stack.pop();
                min.pop();
            }
        }

        public int top() {
            if (!stack.isEmpty()) {
                return stack.peek();
            }
            throw new IllegalStateException();
        }

        public int getMin() {
            if (!min.isEmpty()) {
                return min.peek();
            }
            throw new IllegalStateException();
        }
    }

Simplify Path

Given an absolute path for a file (Unix-style), simplify it.

For example,
path = "/home/", => "/home"
path = "/a/./b/../../c/", => "/c"

click to show corner cases.

Corner Cases:

• Did you consider the case where path = "/../"?
  In this case, you should return "/".
• Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".
  In this case, you should ignore redundant slashes and return "/home/foo".

    public String simplifyPath(String path) {

        if (path == null) {
            return null;
        }

        String[] names = path.split("/");

        int eat = 0;

        LinkedList<String> stack = new LinkedList<String>();

        for (int i = names.length - 1; i >= 0; i--) {

            String token = names[i];

            // token是".."， 表示上级路径，前一个路径不打印
            // token是"."， 表示当前路径，自身不打印
            // token是"", 表示为两个"/"相连，不做操作
            // eat>0，表示左边不打印
            // 否则，将token入栈
            if (token.equals("..")) {
                eat++;
            } else if (token.equals(".")) {
                // do nothing
            } else if (token.equals("")) {
                // do nothing
            } else {

                if (eat > 0) {
                    eat--;
                } else {
                    stack.push(token);
                }
            }
        }

        StringBuilder s = new StringBuilder();

        s.append("/");

        // 最后一个不加"/"，所以while判断条件是>1
        while (stack.size() > 1) {
            s.append(stack.pop());
            s.append("/");
        }

        // 最后一个不加"/"
        if (!stack.isEmpty()) {
            s.append(stack.pop());
        }

        return s.toString();
    }

Valid Parentheses

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

    public boolean isValid(String s) {

        if (s == null || s.length() % 2 == 1) {
            return false;
        }

        HashMap<Character, Character> map = new HashMap<Character, Character>();
        map.put('(', ')');
        map.put('[', ']');
        map.put('{', '}');

        Stack<Character> stack = new Stack<Character>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (map.keySet().contains(c)) {
                stack.push(c);

            } else if (map.values().contains(c)) {

                if (!stack.empty() && map.get(stack.peek()) == c) {
                    stack.pop();
                } else {
                    return false;
                }
            }
        }

        return stack.empty();
    }