第八周题解

155. 最小栈

方法一：

//用链表实现，后一个结点指向前一个结点，先进后出
class MinStack {
    private Node head;
    
    private class Node {
        int value;
        int min;    //min用来记录当前所有结点的最小值
        Node next;
        
        private Node(int value, int min) {
            this(value, min, null);
        }
        
        private Node(int value, int min, Node next) {
            this.value = value;
            this.min = min;
            this.next = next;
        }
    }
    
	public MinStack() {
    }
    
    public void push(int x) {
        if(head == null) 
            head = new Node(x, x);  //当是头结点的时候，自己的值和最小值都是x
        else 
            head = new Node(x, Math.min(x, head.min), head);  //更新最小值
    }

    public void pop() {
        head = head.next;
    }

    public int top() {
        return head.value;
    }

    public int getMin() {
        return head.min;
    }
    
}

方法二：

public class MinStack {
    private Stack<Integer> data = new Stack<>(); //按顺序记录元素
    private Stack<Integer> min = new Stack<>();  //按顺序记录到每一个元素为止的最小元素

    public MinStack() {

    }

    public void push(int x) {
        data.push(x);
        if (min.isEmpty() || x <= min.peek()) {
            min.push(x);  //如果最小元素的栈为空或者当前元素小于最小元素栈的栈顶，则将当前元素入栈
        } else {
            min.push(min.peek()); //否则将最小元素栈的栈顶再入栈一次
        }
    }

    public void pop() {
        if (!data.isEmpty()) { //两个一起出栈
            min.pop();
            data.pop();
        }
    }

    public int top() {
        return data.peek();
    }

    public int getMin() {
        return min.peek();
    }
}

224. 基本计算器

class Solution {
    public int calculate(String s) {

        Stack<Integer> stack = new Stack<Integer>();
        int operand = 0; //每一个数真实的值，原本为字符，数值为在ASCII中的值
        int result = 0; // 结果
        int sign = 1;  // sign表示正负

        for (int i = 0; i < s.length(); i++) {
            //s.charAt(i)表示字符串s中第i个位置的元素
            char ch = s.charAt(i);
            if (Character.isDigit(ch)) { //Character.isDigit(ch)判断ch是否为数字，是返回true
                operand = 10 * operand + (int) (ch - '0'); //(ch - '0')将其转变为真实的值
                //当运算数为多位，例如123时，需要一位一位的转换，高位的先转换，所以需要(10 * operand)
            } else if (ch == '+') {
                result += sign * operand;
                sign = 1;
                operand = 0;
            } else if (ch == '-') { 
                //相当于所有的运算都是加法运算，当出现减号的时候，即加一个负数
                result += sign * operand;
                sign = -1;
                operand = 0;
            } else if (ch == '(') {
                //当出现括号的时候，就将括号前的结果先入栈保存，然后单独计算括号内的结果
                stack.push(result);
                //sign为括号内的结果的正负值
                stack.push(sign);
                sign = 1;
                result = 0;
            } else if (ch == ')') {
                result += sign * operand;
                //这时候出栈的是当前result的正负
                result *= stack.pop();
                //出栈的是遇到括号以前的结果，然后将括号内的结果加上括号前的结果
                result += stack.pop();
                operand = 0;
            }
        }
        //当字符串最后一个元素是数字的时候，是没有计算的，所以要再计算一下
        return result + (sign * operand);
    }
}

7. 整数反转

class Solution {
    public int reverse(int x) {
        //result的值可能会超过int的范围
        long result = 0, sum;
        while(x != 0){
            sum = x % 10;
            result = result*10 + sum;
            x = x / 10;
        }
        //返回值位int类型的，故需要强制类型转换，如果result的值超过int的范围了则返回0
        return (int)result == result ? (int)result : 0;
    }
}