前言

刷题链接：
https://www.nowcoder.com/exam/oj/ta?page=2&tpId=13&type=265

原定于5.30写完队列&栈，超时了14天（2周），于6.13完成。
刷算法题到现在得出一个心得，万事开头难。没刷之前总觉得这很难那很难，开始刷之后反倒觉得轻松了许多。算法都是有共性的，集中刷一段时间，参考一些好的题解就能有收获。

另外，这两周因为工程任务不断，干净的用于学习的时间很少。因为没有时间完成任务，睡眠质量和心态变差，效率低下，简直是一个恶性循环！

3. 队列 & 栈

JZ9 用两个栈实现队列

在这里插入图片描述
思路：

step 1：正常push到第一个栈末尾。
step 2：将第一个栈的元素弹出，并依次进入第二个栈中。
step 3：第一个栈中最后取出的元素是队列首部元素（此时在第二个栈的首位），直接弹出。
step 4：再将第二个栈中保存的内容，依次弹出，依次进入第一个栈中，保证了顺序不变。

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        while(!stack1.isEmpty()){ // stack1的存入stack2中
            int in = stack1.pop();
            stack2.push(in);
        }
         
        int out = stack2.pop(); //取出队首元素

        while(!stack2.isEmpty()){//其他元素以原顺序存回stack1
            stack1.push(stack2.pop());
        }
        return out;
    }
}

JZ30 包含min函数的栈

在这里插入图片描述
思路：辅助栈存储min，每push一个node到主栈，辅助栈都会存入当前的最小值。

import java.util.Stack;

public class Solution {
    Stack<Integer> s1 = new Stack<Integer>();
    Stack<Integer> s2 = new Stack<Integer>(); //存储min
    
    public void push(int node) {
        s1.push(node);
        if(s2.isEmpty()||s2.peek()>node){
            s2.push(node);
        }else{
            s2.push(s2.peek()); //s2重复加入min
        }
    }
    
    public void pop() {
       s1.pop();
       s2.pop();
    }
    
    public int top() {
        return s1.peek();
    }
    
    public int min() {
        return s2.peek();
    }
}

JZ31 栈的压入、弹出序列

在这里插入图片描述
思路：辅助栈来检查栈输出数组是否符合弹出栈的规律。

当栈为空或者当前栈输入数组元素不等于当前栈输出数组元素的时候，将栈输入元素输入到辅助栈，栈输入数组索引后移。
当辅助栈栈顶元素和当前栈输出数组元素相同时，弹出该元素，否则访问完所有入栈数组还没有弹出所有元素就为false。
两个序列都访问完毕为true

import java.util.Stack;
public class Solution {
    public boolean IsPopOrder(int [] pushA, int [] popA) {
        Stack<Integer> s = new Stack<Integer>();

        int n = pushA.length;
        int j = 0;
        for(int i = 0;i<n;i++){
            while(j<n && (s.isEmpty()||s.peek()!=popA[i])){
                s.push(pushA[j]);
                j++;
            }
            if(s.peek() == popA[i]){
                s.pop();
            }else{
                return false;
            }
        }
        return true;
    }
}

JZ73 翻转单词序列

在这里插入图片描述
思路：首先想到将字符串按照空格拆分开，存到一个String数组里面，得到数组长度即单词个数。然后使用StringBuffe逆向存储字符串数组，同时添加空格，使用lastIndexOf方法得到最后一个空格的索引值，使用delete删除该空格，用toString转换成String类型返回。

没有用到栈的数据结构

import java.util.*;

public class Solution {
    public String ReverseSentence(String str) {
        //按空格拆分单词
        String[] strs = str.split(" ");
        int n =strs.length;

        StringBuffer s = new StringBuffer();
        for(int i=n-1;i>=0;i--){
            s.append(strs[i]);
            s.append(" ");
        }
        int last_space = s.lastIndexOf(" ");
        s.delete(last_space,last_space+1); //删除最后一个
        String res = s.toString();
        return res;
    }
}

import java.util.*;

public class Solution {
    public String ReverseSentence(String str) {
        //按空格拆分单词
        String[] strs = str.split(" ");
        int n =strs.length;

        Stack<String> temp = new Stack<String>();
        for(int i=0;i<n;i++){
            temp.push(strs[i]);
            temp.push(" ");
        }

        StringBuffer s = new StringBuffer();
        if(!temp.isEmpty()){
            temp.pop(); //去掉最后一个空格
        }
        while(!temp.isEmpty()){
            s.append(temp.pop());
        }

        String res = s.toString();
        return res;
    }
}