leetcode刷题笔记 2021-01-25

最新推荐文章于 2022-04-04 00:00:00 发布
最新推荐文章于 2022-04-04 00:00:00 发布
阅读量165 收藏
点赞数
分类专栏： 学习笔记 文章标签： 字符串 指针 队列 leetcode queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43111836/article/details/113143724
版权

题目155.最小栈

  • class MinStack {
    Deque<Integer> xstack;
    Deque<Integer> minStack;
    /** initialize your data structure here. */
    public MinStack() {
        xstack=new LinkedList<Integer>();
        minStack=new LinkedList<Integer>();
        minStack.push(Integer.MAX_VALUE);//缺少这行代码会报空指针错。
        //原因是：pop（）、top（）、getMin（）操作总是在非空栈上调用，栈不能空，所以在初始化的时候提前加了一个最大值。
    }
    
    public void push(int x) {
        xstack.push(x);
        minStack.push(Math.min(minStack.peek(),x));
    }
    
    public void pop() {
        xstack.pop();
        minStack.pop();
    }
    
    public int top() {
        return xstack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

题目225.用队列实现栈

  • class MyStack {
    //两个队列实现
    /*Queue<Integer> queue1;
    Queue<Integer> queue2;
    /** Initialize your data structure here. */
    /*public MyStack() {
        queue1=new LinkedList<Integer>();
        queue2=new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    /*public void push(int x) {
        queue2.offer(x);
        //if(queue1.isEmpty()){//queue1里面元素不止一个，应用循环。
        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() {
        int b=queue1.peek();
        queue1.poll();
        return b;
    }
    
    /** Get the top element. */
   /* public int top() {
        
        return queue1.peek();
    }
    
    /** Returns whether the stack is empty. */
   /* public boolean empty() {
        return queue1.isEmpty();
    }*/

    //一个队列实现
        /** Initialize your data structure here. */
    Queue<Integer> queue;
    public MyStack() {
        queue=new LinkedList<Integer>();
       
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        int n=queue.size();
        queue.offer(x);
        for(int i=0;i<n;i++){
            queue.offer(queue.poll());
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {

        return queue.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty();
    }

}

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

题目232.用栈实现队列

  • class MyQueue {
    Deque<Integer> stack1;
    Deque<Integer> stack2;
    int front;
    /** Initialize your data structure here. */
    public MyQueue() {
        stack1=new LinkedList<Integer>();
        stack2=new LinkedList<Integer>();

    }


    
    /* Push element x to the back of queue. */
    public void push(int x) {
        //解法一
       /* while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        stack1.push(x);
        while(!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }*/

        //解法二
        if(stack1.isEmpty()){
            front=x;
        }
        stack1.push(x);


    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        //解法一
        //return stack1.pop();

        //解法二
        if(stack2.isEmpty()){
            while(!stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    } 
    
    /** Get the front element. */
    public int peek() {
        //解法一：return stack1.peek();
        //解法二：
        if(stack2.isEmpty()){
            return front;
        }else{
            return stack2.peek();
        }
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        //解法一:return stack1.isEmpty();
        //解法二：
        return stack2.isEmpty()&&stack1.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();
 */

题目493.下一个更大元素

  • 单调栈+哈希map

  • //本人解法
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Deque<Integer> stack=new LinkedList<Integer>();
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();
        int ans[]=new int[nums1.length];
        for(int i=0;i<nums2.length;i++){
        while((!stack.isEmpty())&&nums2[i]>stack.peek()){
            
            map.put(stack.pop(),nums2[i]);
        }
        stack.push(nums2[i]);
        }
        for(int i=0;i<nums1.length;i++){
            if(map.containsKey(nums1[i])){
                 ans[i]=map.get(nums1[i]);
            }else{
                ans[i]= -1;
            }
        }
        return ans;
    }
}

  • 
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Deque<Integer> stack=new LinkedList<Integer>();
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();
        int ans[]=new int[nums1.length];
        for(int i=0;i<nums2.length;i++){
        while((!stack.isEmpty())&&nums2[i]>stack.peek()){
            
            map.put(stack.pop(),nums2[i]);
        }
        stack.push(nums2[i]);
        }
        //本人用for（）循环实现
        /*for(int i=0;i<nums1.length;i++){
            if(map.containsKey(nums1[i])){
                 ans[i]=map.get(nums1[i]);
            }else{
                ans[i]= -1;
            }
        }*/
        //官方题解:
        while(!stack.isEmpty()){
            map.put(stack.pop(),-1);//栈中最后剩下的元素跟-1对应起来。
        }
        for(int i=0;i<nums1.length;i++){
            ans[i]=map.get(nums1[i]);
        }
        return ans;
    }
}

题目682.棒球比赛

  • 首先想到用哈希map记录x,+,D,C分别对应得操作，但是不知如何实现对前面得分的操作。

  • 既然是栈这一节，考虑能不能用栈实现？

  • 突然想到能不能用递归？因为有些操作是对前次得分的操作，函数最后返回的是得分。但是递归结束条件不是很明显。

  • 将字符串入栈，x入栈，+把栈的元素弹出并且入栈（能够将前两次的值弹出加起来再分别入栈吗）（可以实现），c就把栈顶元素删除，D就取栈顶值2入栈。

  • class Solution {
    public int calPoints(String[] ops) {
        int ans=0;
        Deque<Integer> stack=new LinkedList<Integer>();
        for(int i=0;i<ops.length;i++){
           if(ops[i].equals("+")){
               int a=stack.pop();
               int b=stack.peek();
               //int b=stack.pop();
              // stack.push(b)
               stack.push(a);
               stack.push(a+b);
           }else if(ops[i].equals("D")){
               stack.push(stack.peek()*2);
           }else if(ops[i].equals("C")){
               stack.pop();
           }else{
               stack.push(Integer.parseInt(ops[i]));
           }
        }
        while(!stack.isEmpty()){
            ans=stack.pop()+ans;
        }

        return ans;
    }
}

  • 两个方法内存消耗差0.lMB，全国排名差了60%。

题目844.比较含退格的字符串

  • 本题需要先对字符串进行处理，之后再比较

  • 退格字符串左侧字母删掉

  • 需对字符串操作

  • 遍历字符串找到所有退格字符，将其左侧字符删掉。

  • 可考虑将字符串入栈，当遇到退格字符时，栈顶值pop。当栈为空遇到退格字符不操作。

  • 对两个栈中元素进行比较，循环出栈。

    class Solution {
    public boolean backspaceCompare(String S, String T) {
        //自己解法：
        /*Deque<Character> stack1=new LinkedList<Character>();
        Deque<Character> stack2=new LinkedList<Character>();
        for(int i=0;i<S.length();i++){
            if(S.charAt(i) == '#'&&(!stack1.isEmpty())){
                stack1.pop();
            }else if(S.charAt(i) == '#'){
                stack1.push(S.charAt(i));
            }else{
                stack1.push(S.charAt(i));
            }
        }
        for(int i=0;i<T.length();i++){
            if(T.charAt(i) == '#'&&(!stack2.isEmpty())){
                stack2.pop();
            }else if(T.charAt(i) == '#'){
                stack2.push(T.charAt(i));
            }else{
                stack2.push(T.charAt(i));
            }
        }
        while(!stack1.isEmpty()&&!stack2.isEmpty()){
            if(stack1.pop()!=stack2.pop()){
                return false;
            }
        }
     return (stack1.isEmpty()||stack1.peek()=='#')&&(stack2.isEmpty()||stack2.peek()=='#');*/
     //官方解法：重构字符串
        return build(S).equals(build(T));
    }
            public String build(String str){
            StringBuffer ret=new StringBuffer();
            int length=str.length();
            for(int i=0;i<length;i++){
                char ch=str.charAt(i);
                if(ch!='#'){
                    ret.append(ch);
                }else{
                    if(ret.length()>0){
                        ret.deleteCharAt(ret.length()-1);
                    }
                }
            }
            return ret.toString();
        }
}

  • /

    //双指针
class Solution {
    public boolean backspaceCompare(String S, String T) {
        //自己解法：
        /*Deque<Character> stack1=new LinkedList<Character>();
        Deque<Character> stack2=new LinkedList<Character>();
        for(int i=0;i<S.length();i++){
            if(S.charAt(i) == '#'&&(!stack1.isEmpty())){
                stack1.pop();
            }else if(S.charAt(i) == '#'){
                stack1.push(S.charAt(i));
            }else{
                stack1.push(S.charAt(i));
            }
        }
        for(int i=0;i<T.length();i++){
            if(T.charAt(i) == '#'&&(!stack2.isEmpty())){
                stack2.pop();
            }else if(T.charAt(i) == '#'){
                stack2.push(T.charAt(i));
            }else{
                stack2.push(T.charAt(i));
            }
        }
        while(!stack1.isEmpty()&&!stack2.isEmpty()){
            if(stack1.pop()!=stack2.pop()){
                return false;
            }
        }
     return (stack1.isEmpty()||stack1.peek()=='#')&&(stack2.isEmpty()||stack2.peek()=='#');*/
     //官方解法：
      /*  return build(S).equals(build(T));
    }
            public String build(String str){
            StringBuffer ret=new StringBuffer();
            int length=str.length();
            for(int i=0;i<length;i++){
                char ch=str.charAt(i);
                if(ch!='#'){
                    ret.append(ch);
                }else{
                    if(ret.length()>0){
                        ret.deleteCharAt(ret.length()-1);
                    }
                }
            }
            return ret.toString();*/

            //双指针：
            int i=S.length()-1,j=T.length()-1;
            int skipS=0,skipT=0;
            while(i>=0 || j>=0){//当两个字符串的指针都小于0退出循环
                while(i>=0){//对字符串s处理，若是#则skipS加一，说明前面多一个被抵消的字符。
                    //若不是#且skipS>0说明是个需要删掉的字符。两者都不是则是需要保留的字符，跳出循环去跟另一个字串比较。
                    if(S.charAt(i)=='#'){
                        skipS++;
                        i--;
                    }else if(skipS>0){
                        skipS--;
                        i--;
                    }else{
                        break;
                    }
                }
                while(j>=0){
                    if(T.charAt(j)=='#'){
                        skipT++;
                        j--;
                    }else if(skipT>0){
                        skipT--;
                        j--;
                    }else{
                        break;
                    }
                }
                //判断条件：
                //如果这个字符不相等，直接返回false
                //如果这个字符只是一个字串有，另一个字串指针已经<0，则数目不匹配。
                //这里之所以要排除return false而不是直接限定相等的情况，是因为这只是判断一个字符，即使判断出相等也无法返回true，相反判断出不相等可以直接返回false。
                if(i>=0&&j>=0){
                    if(S.charAt(i)!=T.charAt(j)){
                        return false;
                    }
                }else{
                    if(i>=0||j>=0){
                        return false;
                    }
                }
                i--;
                j--;
            }
            return true;//当两个字符都遍历完之后，若还是不不相等，则返回true。

        }
}
    • 双指针解法时间复杂度O(N+M),空间复杂度O(1)。
涛&宇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2021-04-24 leetcode刷题
hhx7777777777777的博客
04-24 97
学习目标： leetcode刷题 学习内容： 移动零 （1）：暴力破解 （2）：双指针 link：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2ba4i/ 两数之和 （1）：改进的暴力破解 （2）：hashmap link:https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2jrse/ 学习时间： 2021.4.24 下午 学习产出
leetcode刷题笔记-trie
Sengo的博客
10-06 633
复习时候做421 642.Design Search Autocomplete System class TrieNode(): def __init__(self): self.children = collections.defaultdict(TrieNode) self.isEnd = False self.rank ...
Java的Queue和Deque
小威的博客
12-14 861
文章目录继承关系Queue添加元素取出元素推荐使用Deque添加元素取出元素 继承关系 Queue Queue<Integer> queue = new LinkedList<Integer>(); 添加元素 queue.add(1); queue.offer(1); 区别：在容量已满的情况下，add() 方法会抛出IllegalStateException异常，offer() 方法只会返回 false 。 取出元素 queue.remove(); queue.poll();
Java双端队列Deque的使用
weixin_48488560的博客
03-01 319
Deque是一个双端队列接口，继承自Queue接口，Deque的实现类是LinkedList、ArrayDeque、LinkedBlockingDeque，其中LinkedList是最常用的。 Deque有三种用途： 普通队列(一端进另一端出): Queue queue = new LinkedList()或Deque deque = new LinkedList() 双端队列(两端都可进出) Deque deque = new LinkedList() 堆栈...
栈与队列理论基础
jiayoudangdang的博客
12-07 930
栈stack的用法 实例化一个对象 Stack<Integer> stack = new Stack<>(); 用这个对象调用函数 判断是否为空 stack.empty() 入栈 stack.push('a'); 出栈，并作为此函数的值返回该对象 stack.pop(); 返回对象在栈中的位置 stack.search('b')，从1开始，从栈顶开始 查看栈顶部的对象，但不从栈中移除它 Object peek( ) 队列queue的用法 LinkedList类实.
Leetcode——最小栈（使用链表辅助）
Yawn
07-13 140
1. 题目 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 2. 题解 让我们自定义一个栈，有push，pop，top，min四个函数。这题和官方的Stack相比就多了一个min函数。栈的实现我们可以使用链表，先来定义一个链表类 class ListNode { public int val;
数据结构：栈
m0_59499084的博客
10-31 316
栈 是一种具有[先进后出]特点的抽象数据结构，可使用数组或者链表来实现。 Stack<Integer> stack = new Stack<>(); 如下图所示，通过常用的操作[入栈 push()]，[出栈 pop()]，展示了栈的先入后出的特性。 stack.push(1);//元素1入栈 stack.push(2);//元素2入栈 stack.push();//元素出栈 -> 元素2 stack.push();//元素出栈 -> 元素1 注意：.
Leetcode刷题笔记-堆
最新发布
08-19
Leetcode刷题笔记—堆相关题型，刷透一道题顶10盲刷10道题，还在苦苦纠结于打开力扣直奔题解的苦恼吗? 赶快来看一看吧
谷歌师兄的leetcode刷题笔记-blog:博客
06-30
谷歌师兄的leetcode刷题笔记完美无瑕 一个基于 Tufte CSS 的漂亮、快速、兼容 AMP 的 Jekyll 主题。 Immaculate 真的很快，这要归功于 Google AMP。 当通过 Google 的 CDN 提供服务时，您会看到典型的...
谷歌师兄的leetcode刷题笔记-momentum:势头
06-30
谷歌师兄的leetcode刷题笔记动力是给男人的 我们的重点是男人的工作，并成为我们能做到的最好的男人。 我们支持男人拥有真正的友谊 当然，我们喜欢一起玩乐，但我们正在寻找更多的东西：与我们信任的伟人建立真正的...
谷歌师兄的leetcode刷题笔记-saltride:盐渍
06-30
谷歌师兄的leetcode刷题笔记离子盐之旅 IonSaltRide 是一个实验项目，旨在提供一个易于使用的移动应用程序，以帮助我们丰盛生命教会的访客和工作人员。 这是一个绿色项目，将专注于它的可用性，以帮助新用户和有经验...
Leetcode刷题笔记-大厂面试突破集
08-15
LeetCode 是一个在线编程练习平台，特别受到程序员和求职者们的欢迎，因为它包含了大量面试常考的算法题目。本文将围绕LeetCode上的题目，重点解析其中涉及的数据结构、算法及其在实际面试中的应用。 首先，从题目...
【leetcode】栈 - 最小栈
码农研究僧的博客
12-07 335
题目： 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 示例: 输入： [“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”] [[],[-2],[0],[-3],[],[],[],[]] 输出： [null,null,null,n
Java中的栈Stack、Deque、ArrayDeque、LinkedList
编程架构三分天下：分层、分治、分时序。
10-12 1万+
文章目录先来说说Java中的Stack类不用Stack至少有以下两点原因该用ArrayDeque还是LinkedList？结论 先来说说Java中的Stack类 Java中Stack类从Vector类继承，底层是用数组实现的线程安全的栈。栈是一种后进先出(LIFO)的容器，常用的操作push/pop/peek。 不过Java中用来表达栈的功能（push/pop/peek），更适用的是适用双端队列接口Deque，并用ArrayDeque/LinkedList来进行初始化。 Deque<Integer&g
LeetCode-155. 最小栈(java)
**My Coding Family**
04-04 668
金三银四，又到了刷题月。有时间的话，希望大家还是尽量刷起来咯。帮助往往不是直接体现出来的，但会让你对很多东西的底层实现了解的更深刻。
Java 数据结构之 Stack(栈)
热门推荐
Ricky
03-08 1万+
栈是重要的数据结构，从数据结构角度看，栈也是线性表，其特殊性在栈的基本操作是线性表的子集。Stack作为最基本的数据结构，在JDK代码中，也有它的实现，java.util.Stack类是继承了Vector类，来实现了栈的基本功能。   一、栈的基本原理   栈（Stack）是限定仅在表尾进行插入或者删除操作的线性表。因此，对于栈来说，表尾端有特殊含义，成为栈顶，表头称之为栈
linkedlist和stack异同
qq_38056704的博客
09-07 3767
1.add和push比较 /** * linkedlist vs stack */ public static void test3() { //add测试 //结论：add测试一样 LinkedList&lt;Integer&gt; linkedList = new LinkedList&lt;&gt;(); Stack&lt;Integer&gt; stack ...
六万字数据结构基础知识大总结(含笔试面试习题)
耀的博客
12-24 3319
Java数据结构大总结，适合新手入门学习，总结，创作不易，求点赞，求收藏，让我们一起学起来！！！
面经笔记12-4
weixin_43111836的博客
12-04 941
同步异步、阻塞非阻塞 答： 同步指的是主程序必须接受到调用程序结果后才能继续执行。异步则指调用程序后立即返回， 主程序继续向下执行，被调用程序执行完后通过消息、回调等机制通知主程序。 阻塞指的是被调用程序没有返回前，当前线程暂时被挂起，等待程序返回。非阻塞指的是在不能立刻得到调用结果前，当前线程不会被阻塞。 同步异步强调消息通信机制，阻塞非阻塞强调主程序状态。同步调用时主程序仍处于激活状态只是没有返回值。阻塞调用主程序暂时被挂起。 直接搜集面经答案，打印出来背可能更快。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值