版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_28057541/article/details/72627665
算法练习 - 栈
关于栈的使用，难度从简单到难
练习1LeetCode - 496. Next Greater Element I
class Solution(object):
# 输入:两个无重复的数列nums1和nums2，其中nums1是nums2的一个子集。找出所有的nums中元素之后行下一个比其大的元素在nums2中的位置
# 输出：下一个较大位置的数列
# nums1 和 nums2 中的所有数都是独一无二的
# nums1 和 nums2 的大小不超过1000
# 如果暴力的做，就是遍历nums1然后在nums2中去找对应的比它大一位数的位置，时间复杂度O(n2)
# nums1 和 nums2 中的所有数都是独一无二的，那么就说明 (数-位置) 形成了映射关系,这种映射关系可以在线性时间内完成
# 找到每个数的下一个大的数的序列，也就等于找到了位置序列
def nextGreaterElement(self, findNums, nums):
"""
:type findNums: List[int]
:type nums: List[int]
:rtype: List[int]
"""
# 设 d_next 为nums中数对应下一大数的映射关系
d = {}
# 设 s 为一个空的栈
s = []
# 遍历 nums，当前元素为x：
for x in nums:
# 如果 s 不为空 且 栈顶 < x，在d中添加对应的映射关系，并将当前栈顶数出栈：
while len(s) and s[-1] < x:
d[s.pop()] = x
# 否则，继续入栈
s.append(x)
# 设 ans 为返回序列
ans=[]
# 遍历 findnums ，x:
for x in findNums:
# 在d中查找对应的x是否存在映射关系：
# 如果存在：
# ans中添加当前x的对应的下一大
# 不存在：
# ans中添加-1
ans.append(d.get(x,-1))
# 返回ans
return ans练习2 LeetCode - 173. Binary Search Tree Iterator
class BSTIterator(object):
def __init__(self, root):
"""
:type root: TreeNode
"""
# 用栈来初始化
self.s = []
curNode = root
while curNode:
self.s.append(curNode)
curNode = curNode.left
# 判断是否存在下一个最小值
def hasNext(self):
"""
:rtype: bool
"""
# 如果s不为空，则返回栈顶
if len(self.s):
return True
else:
return False
# next 返回的是下一个最小值，也就是当前结点的左子节点
def next(self):
"""
:rtype: int
"""
curTop = self.s.pop()
# 将下一个大小的入栈
if curTop.right:
if curTop.right.left:
temp = curTop.right
while temp:
self.s.append(temp)
temp = temp.left
else:
self.s.append(curTop.right)
return curTop.val
练习3 LeetCode - 341. Flatten Nested List Iterator
class NestedIterator(object):
# 不能直接遍历的原因，可能嵌套很多层，如果每次都指定一个新的指针来控制list的迭代，而且你不知道到底深度为多少，算法复杂度会很高
def __init__(self, nestedList):
"""
Initialize your data structure here.
:type nestedList: List[NestedInteger]
"""
# 首先逆序入栈
self.list = []
self.ans = []
for i in nestedList:
self.list.append(i)
# 利用栈的特性将数列展开
# 如果说队列为空,那么直接返回
if not len(self.list):
return
# 否则，将当前栈顶展开入栈
while len(self.list):
# 如果栈顶元素存在且不是数字，而是数列
curNested = self.list.pop()
if curNested and (not curNested.isInteger()):
# 那么将数列展开，逆序入栈
for i in curNested.getList():
self.list.append(i)
# 如果栈顶元素是数字，将栈顶元素的值输入一个list
else:
self.ans.append(curNested.getInteger())
def next(self):
"""
:rtype: int
"""
return self.ans.pop()
def hasNext(self):
"""
:rtype: bool
"""
if len(self.ans):
return True
else:
return False我的方法是先全部展开，参考其他的答案，也每次获取下一个的时候展开，这样可以节约一定的空间,不过时间上的消耗也更多了
class NestedIterator(object):
# 不能直接遍历的原因，可能嵌套很多层，如果每次都指定一个新的指针来控制list的迭代，而且你不知道到底深度为多少，算法复杂度会很高
def __init__(self, nestedList):
"""
Initialize your data structure here.
:type nestedList: List[NestedInteger]
"""
# 首先逆序入栈
self.list = []
for i in reversed(nestedList):
self.list.append(i)
def next(self):
"""
:rtype: int
"""
return self.list.pop()
def hasNext(self):
"""
:rtype: bool
"""
# 当 栈栈元素为一个数字 的时候，才能返回true
while len(self.list):
# cur 为 栈顶元素
cur = self.list[-1]
# 如果栈顶元素为一个数字，返回返回真
if cur.isInteger():
return True
# 否则 则说明当前栈顶为一个数列，展开数列
else:
# pop出当前的cur
cur = self.list.pop()
# 并且逆序的填入栈中
for i in reversed(cur.getList()):
self.list.append(i)
# 然后继续循环
continue
# 遍历到栈空，都没有数字，那就返回空
return False练习4LeetCode - 331. Verify Preorder Serialization of a Binary Tree
class Solution(object):
# 使用先序遍历来序列化一个二叉树，遇数计数，无数记 #
# 判断给定的一个字符串，判断是否是一个二叉树先序序列化后的
def isValidSerialization(self, preorder):
"""
:type preorder: str
:rtype: bool
"""
# 先序遍历的特点是 （自身 - 左 - 右）
# 设 s 为一个栈
s = []
# 设 i 为 0
i = 0
# 将preorder转化为一个字符的list
preorder = preorder.split(',')
# 将 preorder第i个元素 入栈
s.append(preorder[i])
# 如果i小于preorder的size，则循环：
for i in range(1,len(preorder)):
# 判断不符合的情况，也就是按照出入栈规则无法继续的情况：
# 当栈为空的时候，i 还未到 preorder 的边界
# 这种情况下，返回false
if len(s) == 0:
return False
# 如果 当前栈顶 为空 且 如果 preorder[i] 也是空，那么：
if len(s) == 1 and s[-1] == '#':
return False
if preorder[i] == '#':
# 将当前的栈顶元素pop出，然后将新的栈顶元素也pop出
while len(s) and s[-1] == '#':
s.pop()
s.pop()
# 并且将 空 入栈
s.append('#')
# 否则：
else:
# 将preorder[i]入栈
s.append(preorder[i])
# 如果此时栈不为空，则返回false，否则返回true
if len(s) > 1 or s[-1] != '#':
return False
else:
return True练习5 LeetCode - 503. Next Greater Element II
class Solution(object):
"""
同样是找下一个大的数字，不过这次是一个循环列表
那么只有数列中最大的数（或者同样大小的几个数）为-1,其他的所有数都肯定是有一个比它大的数
并且最大数max之前的所有数肯定在一次循环之内可以找到下一个最大数，或者说在遍历到达max就可以找到下一个最大数
而max之后的数，第二遍循环到max的时候，也可以全部找到下一个最大数
也就是当最大的数只有一个的时候，遍历最多两遍可以找到所有下一大
当有多个最大值的时候呢？
想想数列被切分成了好几份，每两个最大值之间的数，一定可以找到最大值，而又是循环的，所以最后一个最大值之后的数字，都可以在第二次遍历到
第一个max之前找到
最重要的是如何判断要跳出循环，特别在多个最大值的时候
直观的来收，是在第二次遍历到最大值的时候，所以应该先用O(n)的时间找到最大值
然后记录遍历的次数，当遍历到第二遍，且已经为最大值的时候，跳出循环
应为存在相同的数不同的位置，所以这次要使用 （位置-下一大）的，也就是说需要一个值来保存当前栈顶的位置，然后每次找到直接在数组中表示出来
"""
def nextGreaterElements(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
# 如果数列的大小为0,返回空
if len(nums) == 0:
return []
# 如果数列的大小为1,那么直接返回[-1]
if len(nums) == 1:
return [-1]
# 遍历一次数组，找到最大值 max_nums
max_nums = max(nums)
# 设 c = 1 为循环的次数
c = 1
# 设 s_nums 为一个用于保存数字栈
s_nums = []
# 设 s_index 为一个用于保存对应数字位置的栈
s_index = []
# 设 ans 为最后的输出，一个所有元素都是-1的，长度和nums相同的数列
ans = [-1]*len(nums)
# 设 i = 0
i = 0
# 遍历 nums,指针为i：
while True:
# 如果当前栈为空：
if len(s_nums) == 0:
# s_nums,s_index直接入栈nums[i]
s_nums.append(nums[i])
s_index.append(i)
i+=1
# 否则：
elif s_nums[-1] == nums[i] and s_nums[-1] == max_nums:
i+=1
else:
# top 为栈顶
top = s_nums[-1]
# 如果 top >= nums[i]：
if top >= nums[i]:
# s_nums 入栈 nums[i]
s_nums.append(nums[i])
# s_index 入栈 i
s_index.append(i)
# i += 1
i += 1
# 如果 top < nums[i]:
else:
# s_nums,s_index出栈当前元素 top ,top_index
s_nums.pop()
# ans中将 top_index 设为 nums[i]
ans[s_index.pop()] = nums[i]
# 如果 i = len(nums):
if i == len(nums):
# i = 0,回到起始点
# c = 2
i,c = 0,2
# 如果 c = 2 且 nums[i] == max_nums 且 最终的栈内应该只包含最大值一个数
if c == 2 and nums[i] == max_nums and len(s_nums) == 1:
# 跳出
break
# 返回 ans
return ans大神的算法瞻仰，逻辑清晰，条例分明，说明还得练啊：
def nextGreaterElements(self, nums):
# 同样是一个栈和一个等长的res列表
stack, res = [], [-1] * len(nums)
# 循环了两遍，同时，简单的循环两遍，节省了很多逻辑
for i in range(len(nums)) * 2:
# 如果 stack 为空，且 栈顶元素 的 大小 小于 nums【i】,则出栈
while stack and (nums[stack[-1]] < nums[i]):
res[stack.pop()] = nums[i]
# 它只用栈保存了位置index，然后通过nums[index]来获取对应的数，很聪明
stack.append(i)
# 最后栈中应该全是最大的那个数
return res