LeetCode | 栈

最新推荐文章于 2022-11-20 22:16:01 发布

库布里没有课

最新推荐文章于 2022-11-20 22:16:01 发布

阅读量102

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/weixin_42945209/article/details/114005651

版权

LeetCode 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

LeetCode | 栈和队列

题20. 有效的括号

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

有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例：

输入：s = "()"
输出：true

输入：s = "()[]{}"
输出：true

输入：s = "(]"
输出：false

输入：s = "([)]"
输出：false

输入：s = "{[]}"
输出：true

思路：

用HashMap储存对应括号，将字符串逐个字符做入栈和出栈

class Solution {
    public boolean isValid(String s) {
        int n=s.length();
        if(n%2==1){
            return false;
        }
        Map<Character,Character> pairs= new HashMap<Character,Character>();
        pairs.put(')','(');
        pairs.put(']','[');
        pairs.put('}','{');

        LinkedList<Character> stack =new LinkedList<Character>();
        for (int i=0;i<n;i++){
            char ch=s.charAt(i);
            if(pairs.containsKey(ch)){
                if(stack.isEmpty()||stack.peek()!=pairs.get(ch)){
                    return false;
                }
                stack.pop();   
            }else{
                stack.push(ch);
            }
        }
        return stack.isEmpty();
    }
}

时间： $O (n)$
空间： $O (n + ∣ Σ ∣)$ ,其中 Σ 表示字符集，本题中字符串只包含 6 种括号，∣Σ∣=6。栈中的字符数量为O(n)，而哈希表使用的空间为 O(∣Σ∣)。

题225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

思路：

class MyStack {
    private Queue<Integer> queue1;
    private Queue<Integer> queue2;
    /** Initialize your data structure here. */
    public MyStack() {
        this.queue1=new LinkedList<Integer>();
        this.queue2=new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue2.offer(x);
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp=queue2;
        queue2=queue1;
        queue1=temp;
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty();
    }
}

题144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

思路一：递归

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> resultList =new ArrayList<Integer>();
        preorder(root,resultList);
        return resultList;
    }

     public void preorder(TreeNode root, ArrayList<Integer> resultList) {
        if(root!=null){
            resultList.add(root.val);
            preorder(root.left,resultList);
            preorder(root.right,resultList);
        }
    }
}

时间： $O (n)$
空间： $O (n)$ , 递归实际上是在使用系统栈，这里的空间开销为递归过程中栈的开销。而栈的开销取决于二叉树的深度，平均情况下为 $O (l o g n)$ ，最坏情况树呈现链状时为 $O (n)$ 。

思路二：栈

遍历树，currentNode先出栈再将currentNode.right入栈，再将currentNode.left入栈

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        LinkedList<Integer> resultList= new LinkedList<Integer>();
        Deque<TreeNode> treeStack=new LinkedList<TreeNode>();
        while(root!=null||!treeStack.isEmpty()){
            while(root!=null){
                treeStack.push(root);
                resultList.add(root.val);
                root=root.left;
            }
            root=treeStack.pop();
            root=root.right;
        }
        return resultList;
    }
}

时间： $O (n)$ ，每个节点入栈和出栈一次
空间： $O (n)$ ，为迭代过程中显式栈的开销，平均情况下为 $O (l o g n)$ ，最坏情况下树呈现链状，为 $O (n)$ 。

思路三：Morris 遍历

题94. 二叉树的中序遍历

给你二叉树的根节点 root ，返回它节点值的中序遍历。

思路一：递归

class Solution {
    public List<Integer> inorderTraversal(TreeNode root){
        ArrayList<Integer> resultList=new ArrayList<Integer>();
        inorder(root,resultList);
        return resultList;
    }

    public void inorder(TreeNode root,ArrayList<Integer> resultList){
        if(root==null){
            return;
        }
        inorder(root.left,resultList);
        resultList.add(root.val);
        inorder(root.right,resultList);
    }
}

时间： $O (n)$
空间： $O (n)$ , 平均情况下为 $O (l o g n)$ ，最坏情况树呈现链状时为 $O (n)$ 。

思路二：栈

class Solution {
    public List<Integer> inorderTraversal(TreeNode root){
        ArrayList<Integer> resultList=new ArrayList<Integer>();
        Deque<TreeNode> treeStack=new LinkedList<TreeNode> ();
        while(root!=null || !treeStack.isEmpty()){
            while(root!=null){
                treeStack.push(root);
                root=root.left;
            }
            root=treeStack.pop();
            resultList.add(root.val);
            root=root.right;
        }
        return resultList;
    }
}

时间： $O (n)$
空间： $O (n)$ 。栈的开销取决于二叉树的深度，平均情况下为 $O (l o g n)$ ，最坏情况树呈现链状时为 $O (n)$ 。

题145. 二叉树的后序遍历

给定一个二叉树，返回它的后序遍历。

思路一：递归

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> resultsList=new ArrayList<Integer> ();
        postorder(root,resultsList);
        return resultsList;
    }

     public void postorder(TreeNode root,ArrayList<Integer> resultsList) {
        if(root == null){
            return;
        }
        postorder(root.left,resultsList);
        postorder(root.right,resultsList);
        resultsList.add(root.val);
    }
}

时间： $O (n)$
空间： $O (n)$ , 平均情况下为 $O (l o g n)$ ，最坏情况树呈现链状时为 $O (n)$ 。

思路二：栈

要注意讨论root.righ是否tnull || root.rightprev的情况

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> resultsList=new ArrayList<Integer> ();
        Deque<TreeNode> treeStack=new LinkedList<TreeNode>();
        TreeNode prev = null;
        while(root!=null || !treeStack.isEmpty()){
            while(root!=null){
                treeStack.push(root);
                root=root.left;
            }
            root=treeStack.pop();
            if(root.right==null || root.right==prev){
                resultsList.add(root.val);
                prev=root;
                root=null;
            }else{
                treeStack.push(root);
                root=root.right;
            }
        }
        return resultsList;
    }
}

时间： $O (n)$
空间： $O (n)$ 。栈的开销取决于二叉树的深度，平均情况下为 $O (l o g n)$ ，最坏情况树呈现链状时为 $O (n)$ 。

题102. 二叉树的层序遍历

给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）

思路一：递归

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> resultsList=new ArrayList<Integer> ();
        postorder(root,resultsList);
        return resultsList;
    }

     public void postorder(TreeNode root,ArrayList<Integer> resultsList) {
        if(root == null){
            return;
        }
        postorder(root.left,resultsList);
        postorder(root.right,resultsList);
        resultsList.add(root.val);
    }
}

时间： $O (n)$
空间： $O (n)$ , 平均情况下为 $O (l o g n)$ ，最坏情况树呈现链状时为 $O (n)$ 。

库布里没有课

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode | 栈

LeetCode | 栈题20. 有效的括号给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。示例：输入：s = "()"输出：true输入：s = "()[]{}"输出：true输入：s = "(]"输出：false输入：s = "([)]"输出：false输入：s = "{[]}"输出：true思路：用HashMap储存对应括号，
复制链接

扫一扫