Leetcode刷题之栈

1、（面试题03.04）化栈为队

实现一个MyQueue类，该类用两个栈来实现一个队列。

//直接使用java的栈Stack即可，当出元素的栈里没有元素时，先将入元素的栈里的元素导入出元素的栈中。
class MyQueue {

    Stack<Integer> inStack = new Stack();
    Stack<Integer> outStack = new Stack();

    /** Initialize your data structure here. */
    public MyQueue() {

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

    public void transfer(){
        if(!outStack.isEmpty())return;
        while(!inStack.isEmpty()){
            outStack.push(inStack.pop());
        }
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        transfer();
        return outStack.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        transfer();
        return outStack.peek();
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return outStack.isEmpty()&&inStack.isEmpty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

2、（682）棒球比赛

你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。

比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：

整数 x - 表示本回合新获得分数 x
“+” - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。
“D” - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。
“C” - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。
请你返回记录中所有得分的总和。

//直接用栈进行操作
class Solution {
    public int calPoints(String[] ops) {
        Stack<Integer> score = new Stack();
        for(int i = 0;i<ops.length;i++){
            switch(ops[i]){
                case "+":
                    int first = score.pop();
                    int second = score.pop();
                    score.push(second);
                    score.push(first);
                    score.push(second+first);
                    break;
                case "C":
                    score.pop();
                    break;
                case "D":
                    score.push(score.peek()*2);
                    break;
                default:
                    score.push(Integer.parseInt(ops[i]));
            }
        }
        int sum = 0;
        while(!score.isEmpty()){
            sum+=score.pop();
        }
        return sum;
    }
}

3、（844）比较含退格的字符串

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空

//解法一、使用StringBuilder拼接字符
class Solution {
    public boolean backspaceCompare(String s, String t) {
        return backspace(s).equals(backspace(t));
    }

    public String backspace(String str){
        StringBuilder stringBuilder = new StringBuilder();
        for(int i = 0;i<str.length();i++){
            char ch = str.charAt(i);
            if(ch=='#'){
                if(stringBuilder.length()>0){
                    stringBuilder.deleteCharAt(stringBuilder.length()-1);
                }
            }else{
                stringBuilder.append(ch);
            }
        }
        return stringBuilder.toString();
    }
}

//解法二、双指针,从两个字符串后往前遍历
class Solution {
    public boolean backspaceCompare(String s, String t) {
        int count1 = 0;
        int count2 = 0;
        int len1 = s.length()-1;
        int len2 = t.length()-1;
        while(len1>=0||len2>=0){
            while(len1>=0){
                if(s.charAt(len1)=='#'){
                    count1++;
                    len1--;
                }else if(count1>0){
                    count1--;
                    len1--;
                }else{
                    break;
                }
            }
            while(len2>=0){
                if(t.charAt(len2)=='#'){
                    count2++;
                    len2--;
                }else if(count2>0){
                    count2--;
                    len2--;
                }else{
                    break;
                }
            }
            if(len1>=0&&len2>=0){
                if(s.charAt(len1)!=t.charAt(len2)){
                    return false;
                }
            }else{
                if(len1>=0||len2>=0)return false;
            }
            len1--;
            len2--;
        }
        return true;
    }
}

4、（946）验证栈序列

给定 pushed 和 popped 两个序列，每个序列中的 值都不重复，只有当它们可能是在最初空栈上进行的推入 push 和弹出 pop 操作序列的结果时，返回 true；否则，返回 false 。

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> stack = new Stack();
        int j = 0 ;
        for(int n : pushed){
            stack.push(n);
            while(!stack.isEmpty()&&j<popped.length&&stack.peek()==popped[j]){
                stack.pop();
                j++;
            }
        }
        return stack.isEmpty();
    }
}

5、（20）有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

class Solution {
    public boolean isValid(String s) {
        HashMap<Character,Character> map = new HashMap<>();
        map.put(')','(');
        map.put(']','[');
        map.put('}','{');
        Stack<Character> stack = new Stack();
        for(int i = 0;i<s.length();i++){
            switch(s.charAt(i)){
                case '(':
                case '[':
                case '{':stack.push(s.charAt(i));break;
                case ')':
                case ']':
                case '}':
                    if(stack.isEmpty()||map.get(s.charAt(i))!=stack.peek())return false;
                    stack.pop();
                    break;
            }
        }
        return stack.isEmpty();

    }
}

6、（1021）删除最外层的括号

有效括号字符串为空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括号字符串。
如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。
对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

//将内层的字符串截取出来
class Solution {
    public String removeOuterParentheses(String S) {
        StringBuilder stringBuilder = new StringBuilder();
        for(int i =0，pre=0,count = 0;i<S.length();i++){
            if(S.charAt(i)=='(')count++;
            else count--;
            //在内层括号
            if(count!=0)continue;
            stringBuilder.append(S.substring(pre+1,i));
            pre=i+1;
        }
        return stringBuilder.toString();
    }
}

7、（1249）移除无效的括号

给你一个由 ‘(’、’)’ 和小写字母组成的字符串 s。
你需要从字符串中删除最少数目的 ‘(’ 或者 ‘)’ （可以删除任意位置的括号)，使得剩下的「括号字符串」有效。
请返回任意一个合法字符串。

//解法一、从左到右过滤一遍，再从右到左过滤一遍
class Solution {
    public String minRemoveToMakeValid(String s) {
        char[] t = new char[s.length()];
        char[] ans = new char[s.length()];
        int tlen = 0;
        for(int i =0,cnt=0;i<s.length();i++){
            if(s.charAt(i)!=')'){
                if(s.charAt(i)=='(')cnt++;
                t[tlen++]=s.charAt(i);
            }else{
                if(cnt==0)continue;
                cnt--;
                t[tlen++]=')';
            }
        }
        int ansHead=tlen;
        for(int i =tlen-1,cnt=0;i>=0;i--){
            if(t[i]!='('){
                if(t[i]==')')cnt++;
                ans[--ansHead]=t[i];
            }else{
                if(cnt==0)continue;
                cnt--;
                ans[--ansHead]='(';
            }
        }
        return new String(ans).trim();
    }
}
//用栈判断括号是否合法，最后再删除对应不合法元素
//栈中存放括号的索引,最终在栈中的都是不合法的
class Solution {
    public String minRemoveToMakeValid(String s) {
        StringBuilder stringBuilder = new StringBuilder(s);
        Deque<Integer> stack = new LinkedList<>();
        for(int i =0;i<s.length();i++){
            if(s.charAt(i)=='('){
                stack.push(i);
            }
            if(s.charAt(i)==')') {
                if (!stack.isEmpty() && s.charAt(stack.peek()) == '(') {
                    stack.pop();
                } else {
                    stack.push(i);
                }
            }
        }
        if(stack.isEmpty()){
            return s;
        }
        for(Integer integer:stack){
            stringBuilder.deleteCharAt(integer);
        }
        return stringBuilder.toString();
    }
}

8、(145)二叉树的后续遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 //用一个栈记录下一步的访问状态，0表示访问左节点，1，表示访问右节点，2表示访问当前节点。
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList();
        if(root==null) return result;
        Deque<TreeNode> stack = new LinkedList();
        Deque<Integer> statusStack = new LinkedList();
        stack.push(root);
        statusStack.push(0);
        while(!stack.isEmpty()){
            switch(statusStack.pop()){
                //访问左节点
                case 0:
                    statusStack.push(1);
                    if(stack.peek().left!=null){
                        stack.push(stack.peek().left);
                        statusStack.push(0);
                    }
                    break;
                //访问右节点
                case 1:
                    statusStack.push(2);
                    if(stack.peek().right!=null){
                        stack.push(stack.peek().right);
                        statusStack.push(0);
                    }
                    break;
                case 2:
                    result.add(stack.pop().val);
                    break;
            }
        }
        return result;
    }
}

（331） 验证二叉树的前序序列化

//当一个数字后面跟着两个#号，可以整个作为一个整体化简为一个#
class Solution {
    public boolean isValidSerialization(String preorder) {
        String[] strings = preorder.split(",");
        List<String> list = new ArrayList();
        for(int i = 0;i<strings.length;i++){
            list.add(strings[i]);
            int lastIndex=list.size()-1;
            while(list.size()>=3&&list.get(lastIndex).equals("#")&&
                list.get(lastIndex-1).equals("#")&&
                !list.get(lastIndex-2).equals("#")){
                    list.set(lastIndex-2,"#");
                    list.remove(lastIndex);
                    list.remove(lastIndex-1);
                    lastIndex=list.size()-1;
            }
        }
        return list.size()==1&&list.get(0).equals("#");
    }
}

//解法二、初始有一个槽，每加一个数字节点占用一个槽，然后用掉两个槽。
class Solution {
    public boolean isValidSerialization(String preorder) {
        int i = 0;
        int slots=1;
        int length = preorder.length();
        while(i<length){
            if(slots==0)return false;
            if(preorder.charAt(i)==','){
                i++;
            }else if(preorder.charAt(i)=='#'){
                slots--;
                i++;
            }else{
                while(i<length&&preorder.charAt(i)!=','){
                    i++;
                }
                slots++;
            }
        }
        return slots==0;
    }
}

(227)基本计算器

//减数直接压入负数
class Solution {
    public int calculate(String s) {
        Deque<Integer> stack = new LinkedList();
        char preSign='+';
        int num = 0;
        int n = s.length();
        for(int i =0;i<n;i++){
            if(Character.isDigit(s.charAt(i))){
                num = num*10+s.charAt(i)-'0';
            }
            if(!Character.isDigit(s.charAt(i))&&s.charAt(i)!=' '||i==n-1){
                switch(preSign){
                    case '+':
                        stack.push(num);
                        break;
                    case '-':
                        stack.push(-num);
                        break;
                    case '*':
                        stack.push(stack.pop()*num);
                        break;
                    case '/':
                        stack.push(stack.pop()/num);
                        break;
                }
                preSign = s.charAt(i);
                num = 0;
            }
        }

        for(int i:stack){
            num+=i;
        }
        return num;
    }
}

(636) 函数的独占时间

class Solution {

    class Task{
        int id=0;
        int time=0;
        boolean isStart=true;
        Task(String[] split){
            id=Integer.valueOf(split[0]);
            time=Integer.valueOf(split[2]);
            isStart=split[1].equals("start");
        }
    }


    public int[] exclusiveTime(int n, List<String> logs) {
        Deque<Task> stack = new LinkedList();
        int[] ans = new int[n];
        for(String log:logs){
            Task task = new Task(log.split(":"));
            if(task.isStart){
                stack.push(task);
            }else{
                Task last = stack.pop();
                int duration = task.time-last.time+1;
                ans[task.id]+=duration;
                if(!stack.isEmpty()){
                    ans[stack.peek().id]-=duration;
                }
            }
        }
        return ans;
    }
}

(1124) 表现良好的最长时间段

//前缀和方式
class Solution {
    public int longestWPI(int[] hours) {
        int sum = 0;
        int res = 0;
        HashMap<Integer,Integer> sumToIndex = new HashMap();
        for(int i = 0;i<hours.length;i++){
            if(hours[i]>8){
                sum++;
            }else{
                sum--;
            }
            if(sum>0){
                //如果前缀和是大于0的，则从头加到尾
                res=i+1;
            }else{
                //用sumToIndex记录sum(前缀和)小于0的最小坐标
                if(!sumToIndex.containsKey(sum)){
                    sumToIndex.put(sum,i);
                }
                //如果有比当前坐标还小一的坐标，则说明当前坐标与那个坐标的前缀和的插值是大于0的。
                if(sumToIndex.containsKey(sum-1)){
                    //结果在已有的最大值和当前坐标前缀和插值进行比较，取最大
                    res = Math.max(res,i-sumToIndex.get(sum-1));
                }
            }
        }
        return res;
    }
}