每日一题之LeetCode 栈简单题集合496,682,232,225,155,844,20

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了每日一题之LeetCode 栈简单题集合496,682,232,225,155,844,20相关的知识,希望对你有一定的参考价值。

496 下一个最大的元素
方法1 :自己瞎写的 没有考虑到栈的特性
class Solution:
def nextGreaterElement(self, nums1, nums2):

     L=[]
    for i in nums1:
         k=nums2.index(i)
         lenth2=len(nums2)
        if k==lenth2-1:
           L.append(-1)
         for j in range(k+1,lenth2):
             if nums2[j]>i:
                 L.append(nums2[j])
                 break

             if j==lenth2-1:
                 L.append(-1)
    return L  

方法2:网上大神写的 很膜拜
class Solution:
def nextGreaterElement(self, nums1, nums2):

                    d = {}
                    st = []
                    ans = []

                    for x in nums2:  
                        while len(st) and st[-1] < x:
                            d[st.pop()] = x
                        st.append(x)

                    for x in nums1:
                        ans.append(d.get(x, -1))

                    return ans

682.棒球比赛
注:好久前写的,后面再吧栈的写出来
ops= ["35","-32","C","39","+","-48","C","5","88","-52","+","C","D","D","100","C","+","-74","53","59"]
L=[]
sum=[]
lenth=len(ops)
for i in range(0,lenth):
if i==0:
sum.append(int(ops[i]))
else:

   if ops[i]==‘C‘:

            sum.insert(0,0)

            sum.insert(1,0)

            sum.pop()

   elif  ops[i]==‘D‘:
    sum.append(sum[i-1]*2)

   elif ops[i]==‘+‘:
    sum.append(sum[i-1]+sum[i-2])
   else :

        sum.append(int(ops[i]))

score=0
for j in sum:
score=score+j
print(score)
232.用栈实现队列
方法1:网上的,用两个list来实现
class MyQueue:

def __init__(self):
    """
    Initialize your data structure here.
    """
    self.stact=[]
    self.queue=[]
    self.len=0

def push(self, x):
    """
    Push element x to the back of queue.
    :type x: int
    :rtype: void
    """
    self.stact.append(x)
    self.len=self.len+1

def pop(self):
    """
    Removes the element from in front of queue and returns that element.
    :rtype: int
    """

    while len(self.stact)!=0:
        self.queue.append(self.stact.pop())

    x = self.queue.pop()

    while len(self.queue)!= 0:
       self.stact.append(self.queue.pop())

    self.len -=1
    return x

def peek(self):
    """
    Get the front element.
    :rtype: int
    """

    while len(self.stact)!=0:
        self.queue.append(self.stact.pop())

    x = self.queue.pop()
    self.queue.append(x)
    while len(self.queue)!= 0:
       self.stact.append(self.queue.pop())

    return x

def empty(self):
    """
    Returns whether the queue is empty.
    :rtype: bool
    """

    if self.len==0:
        return False

方法2:用一个list来实现,比较简单
class MyQueue:

def __init__(self):
    """
    Initialize your data structure here.
    """
    self.queue = []

def push(self, x):
    """
    Push element x to the back of queue.
    :type x: int
    :rtype: void
    """
    self.queue.append(x)

def pop(self):
    """
    Removes the element from in front of queue and returns that element.
    :rtype: int
    """
    if len(self.queue)>0:
       print( self.queue.pop(0))

def peek(self):
    """
    Get the front element.
    :rtype: int
    """
    if len(self.queue)>0:
        print( self.queue[0])

def empty(self):
    """
    Returns whether the queue is empty.
    :rtype: bool
    """
    if len(self.queue)>0:
        return False
    else:
        return True
def shuchu(self):
     for i in self.queue:
         print(i)

235,用队列来实现栈
注:与上面异曲同工
class MyStack:

def __init__(self):
    """
    Initialize your data structure here.
    """
    self.queue = []

def push(self, x):
    """
    Push element x to the back of queue.
    :type x: int
    :rtype: void
    """
    self.queue.append(x)

def pop(self):
    """
    Removes the element from in front of queue and returns that element.
    :rtype: int
    """
    if len(self.queue)>0:
        return self.queue.pop()
        #len(self.queue)-=1

def top(self):
    """
    Get the front element.
    :rtype: int
    """
    if len(self.queue)>0:
        return self.queue[-1]

def empty(self):
    """
    Returns whether the queue is empty.
    :rtype: bool
    """
    if len(self.queue)>0:
        return False
    else:
        return True

155,最小栈
注:可以使用深复制在里面找出来最小值,但会超时,很慢很慢
方法1:用min 函数,较慢,因为每次都执行
class MinStack:

def __init__(self):
    """
    initialize your data structure here.
    """
    self.queue = []
    self.min=None
def push(self, x):
    """
    :type x: int
    :rtype: void
    """
    self.queue.append(x)
    self.min=min(self.queue)

def pop(self):
    """
    :rtype: void
    """
    if len(self.queue)>0:
       self.queue.pop()
       self.min=min(self.queue)
       return self.queue
def top(self):
    """
    :rtype: int
    """
    if len(self.queue)>0:
        return self.queue[-1]

def getMin(self):
    """
    :rtype: int
    """
    return self.min

方法2:判断,比较快
class MinStack(object):
def init(self):
"""
initialize your data structure here.
"""
self.stack = []
self.min = None

def push(self, x):
    """
    :type x: int
    :rtype: void
    """
    self.stack.append(x)
    if self.min == None or self.min > x:
        self.min = x

def pop(self):
    """
    :rtype: void
    """

    popItem = self.stack.pop()
    if len(self.stack) == 0:
        self.min = None
        return popItem

    if popItem == self.min:
        self.min = self.stack[0]
        for i in self.stack:
            if i < self.min:
                self.min = i
    return popItem

def top(self):
    """
    :rtype: int
    """
    return self.stack[-1]

def getMin(self):
    """
    :rtype: int
    """
    return self.min

844.比较含退格的字符串
注:注意遇到‘#’时,字符串长度为0时的处理,以及两个“#”,字符串长度为0时的处理。PS,这是老子自己写出来运行最快的代码了,代码也简洁,写了半个小时吧,有一丢丢自豪。还学会了在类里调用函数。一个类里不能函数调用函数。
class Solution:

def backspaceCompare(self, S, T):
    """
    :type S: str
    :type T: str
    :rtype: bool
    """

    S1=back(S)
    T1=back(T)
    if S1==T1:
        return True
    else:
        return False

def back(L):
K=[]
for i in L:
if i==‘#‘ and len(K)!=0:

               K.pop()
        elif  i==‘#‘ and len(K)==0:
               pass
        else:
            K.append(i)
    return K

20,有效的括号
注:好久前写的了,也是在学栈之前写的,后面把栈的写出来。
class Solution:
def isValid(self, s):

    a=list(s)
    b=[]                            #存放左括号的栈  qc:list当做栈
    c={‘(‘:‘)‘,‘[‘:‘]‘,‘{‘:‘}‘}     #字典存储     qc;key:value 键:值
    for i in a:
        if i==‘‘:
            return True
        elif i in c: #如果是字典中的键,即左括号,放进栈
            b.append(i)
        else:
            if len(b)==0: #先判断是否有左括号存在
                return False
            else:
                 #字典得到该键的值==栈顶值对应的右括号       
                if c.get(b[-1])!=i: 
                    return False
                else:               
                    del b[-1]      #删除栈顶元素
    if len(b)!=0:  #若还存在左括号,此时已没有右括号,出错
        return False
    return True

PS.写这么一些题还是有用的,至少遇到一些题知道其实是采用了栈的思想,以前都是瞎写。编程还是要有思维。

以上是关于每日一题之LeetCode 栈简单题集合496,682,232,225,155,844,20的主要内容,如果未能解决你的问题,请参考以下文章

每日一题之LeetCode 171excel表列序号

每日一题之LeetCode35搜索插入位置

每日一题之 LeetCode实现strstr()

每日一题篇 — leetcode38号题之外观数列

每日一题之LeetCode237删除链表中的节点876链表的中间节点

每日一题 LeetCode 有效的数字 Python实现