def decodeString(self, s):
"""
:type s: str
:rtype: str
"""
stack = list(s)
print (stack)
temp_stack = []
while stack:
ele = stack.pop()
if ele.isnumeric():
while stack and stack[-1].isnumeric():
ele += stack.pop()
res = int(ele[::-1])
y = ""
while temp_stack:
ele2 = temp_stack.pop()
if ele2 != ']':
if ele2 != '[':
y += ele2
else:
break
z = ""
for _ in range(res): # z = y * res
z += y
temp_stack.append(z)
while temp_stack:
stack.append(temp_stack.pop())
else:
temp_stack.append(ele)
temp_stack.reverse()
return ("".join(temp_stack))
def exclusiveTime(self, n, logs):
"""
:type n: int
:type logs: List[str]
:rtype: List[int]
"""
prev=0
curr=0
stack=[]
res=[0 for i in range(n)]
for i in range(len(logs)):
log=logs[i]
val=log.split(':')
functionid=int(val[0])
curr=int(val[2])
#when the function is start then we push it to the stack and we manage curr and prev.
if val[1]=='start':
if len(stack)>0:
res[stack[-1]]=res[stack[-1]]+curr-prev
prev=curr
stack.append(functionid)
#If the fucntion is end then we manage curr and prev and pop the element from the stack.
else:
res[functionid]=res[functionid]+curr-prev+1
prev=curr+1
stack.pop()
return res
def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
ans = [0] * len(temperatures)
stack = []
for i, t in enumerate(temperatures):
while stack and t > temperatures[stack[-1]]:
cur = stack.pop()
ans[cur] = i - cur
stack.append(i)
return ans
def dailyTemperatures(self, T: List[int]) -> List[int]:
stack = []
ans = [0] * len(T)
for i, v in enumerate(T):
while stack and v > T[stack[-1]]:
cur = stack.pop()
ans[cur] = i - cur
stack.append(i)
return ans
def dailyTemperatures(self, T):
ans = [0] * len(T)
stack = []
for i, t in enumerate(T):
while stack and T[stack[-1]] < t:
cur = stack.pop()
ans[cur] = i - cur
stack.append(i)
return ans
def calculate(self, s):
"""
:type s: str
:rtype: int
"""
stack=[]
sign='+'
val=0
result=0
for i in range(len(s)):
if s[i].isdigit():
val=val*10+(ord(s[i])-ord('0'))
if (not s[i].isdigit() and s[i]!=' ') or i==len(s)-1:
if sign=='+':
stack.append(val)
if sign=='-':
stack.append(-1*val)
if sign=='*':
stack.append(stack.pop()*val)
if sign=='/':
ele=stack.pop()
if ele<0:
ele=-1*ele
ele=ele/val
ele=-1*ele
else:
ele=ele/val
stack.append(ele)
sign=s[i]
val=0
# print(stack,sign,val)
while len(stack)>0:
result=result+stack.pop()
return result
def verifyPreorder(self, preorder: List[int]) -> bool:
lo = -inf
stack = []
for val in preorder:
if val <= lo:
return False
while stack and stack[-1] < val:
lo = stack.pop()
stack.append(val)
return True
def verifyPreorder(self, preorder: List[int]) -> bool:
## RC ##
## APPROACH : MONOTONOUS DECREASING STACK ##
## Similar to Leetcode: 94 Binary tree inorder traversal ##
## Similar to leetcode : 98 Validate Binary Search Tree #
## LOGIC ##
## 1. First we push all elements less than TOS (left childs)
## 2. If we encounter any big number than TOS, (indicates start of right childs), we pop all less elements and update lower value. In all such cases x should be more than its parent(lower) else we return False.
## 3. And append the big number to stack (right child) then (go for its left child & repeat process)
## TIME COMPLEXITY : O(N) ##
## SPACE COMPLEXITY : O(N) ##
stack = []
lower = -1 << 31
for x in preorder:
if x < lower:
return False
while stack and x > stack[-1]:
lower = stack.pop()
stack.append(x)
return True
# Then we realize that the preorder array can be reused as the stack thus achieve O(1) extra space, since the scanned items of preorder array is always more than or equal to the length of the stack.
## STACK TRACE ##
## [5,2,1,3,6] ##
# [5, 2, 1, 3, 6]
# [5, 2, 1, 3, 6]
# [5, 2, 1, 3, 6]
# [5, 3, 1, 3, 6]
# [6, 3, 1, 3, 6]
## TIME COMPLEXITY : O(N) ##
## SPACE COMPLEXITY : O(1) ##
lower = -1 << 31
i = 0
for x in preorder:
if x < lower:
return False
while i > 0 and x > preorder[i - 1]:
lower = preorder[i - 1]
i -= 1
preorder[i] = x
i += 1
# print(preorder)
return True
def verifyPreorder(self, preorder: List[int]) -> bool:
lower = -float('inf')
stack = []
for curr in preorder:
if curr <= lower: # break BST rule
return False
if not stack or curr < stack[-1]:
stack.append(curr)
continue
while stack and curr >= stack[-1]:
lower = stack.pop()
stack.append(curr)
return True
def nextGreaterElements(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
stack=[]
stack.append(0)
n=len(nums)
result=[-1 for i in range(len(nums))]
#we do it for twice the lenth as it is a circular array
for i in range(1,2*n):
while len(stack)!=0 and nums[i%n]>nums[stack[-1]]:
index=stack.pop()
result[index]=nums[i%n]
stack.append(i%n)
return result
def dailyTemperatures(self, T):
"""
:type T: List[int]
:rtype: List[int]
"""
stack=[]
result=[0 for i in range(len(T))]
stack.append(0)
for i in range(1,len(T)):
while len(stack)!=0 and T[i]>T[stack[-1]]:
index=stack.pop()
result[index]=i-index
stack.append(i)
return result
def evalRPN(self, tokens: List[str]) -> int:
stack=[]
for i in tokens:
if i!='+' and i!='-' and i!='*' and i!='/':
stack.append(i)
else:
val0=int(stack.pop())
val1=int(stack.pop())
if i=='+':
stack.append(val0+val1)
elif i=='-':
stack.append(val1-val0)
elif i=='*':
stack.append(val0*val1)
else:
stack.append(int(val1/val0))
# print(stack,i)
return stack[0]
def removeKdigits(self, num, k):
"""
:type num: str
:type k: int
:rtype: str
"""
if k==0:
return num
if len(num)==1 and k==1:
return '0'
stack=[]
stack.append(num[0])
for i in range(1,len(num)):
if num[i]>=stack[-1]:
stack.append(num[i])
else:
while len(stack)!=0 and num[i]<stack[-1] and k>0:
stack.pop()
k=k-1
stack.append(num[i])
#checking for the k value .If it is not equal to 1 then we pop the elements till it becomes 1
while k>0 and len(stack)>0:
stack.pop()
k=k-1
#This condition is to check for trailing zeros
if len(stack)==0 or ''.join(stack).lstrip('0')=='':
return '0'
else:
return ''.join(stack).lstrip('0')
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = []
result = []
cur = root
if cur == None:
return result
while(cur != None):
if cur.right:
stack.append(cur.right)
stack.append(cur)
cur = cur.left
#cur is the leftmost node
while(len(stack)!=0):
cur = stack.pop()
#cur doesn't have right node
#如果stack顶部的元素和cur一样，说明cur的右边节点还没有print完成，此时不可以pop cur,所以需要放回cur到stack顶部，把cur设置为右边subtree的parent node
if cur.right is not None and (self.peek(stack) == cur.right):
stack.pop()
stack.append(cur) #Push it back
cur = cur.right
#find leftmost node of right subtree
while cur:
if cur.right:
stack.append(cur.right)
stack.append(cur)
cur = cur.left
else:
result.append(cur.val)
cur = None
return result
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
if s==None or len(s)==0:
return True
stack=[]
for i in range(len(s)):
if s[i]=='[' or s[i]=='{' or s[i]=='(':
if s[i]=='[':
stack.append(']')
if s[i]=='{':
stack.append('}')
if s[i]=='(':
stack.append(')')
else:
if len(stack)>0 and stack[-1]==s[i]:
stack.pop()
else:
return False
if len(stack)==0:
return True
return False
The algorithm has two steps:
Find the midpoint of the linked list
Push the second half values into the stack
Pop values out from the stack, and compare them to the first half of the linked list
The advantages of this algorithm are we don't need to restore the linked list and the space complexity is acceptable (O(N/2))
def isPalindrome(self, head):
if not head or not head.next:
return True
# 1. Get the midpoint (slow)
slow = fast = cur = head
while fast and fast.next:
fast, slow = fast.next.next, slow.next
# 2. Push the second half into the stack
stack = [slow.val]
while slow.next:
slow = slow.next
stack.append(slow.val)
# 3. Comparison
while stack:
if stack.pop() != cur.val:
return False
cur = cur.next
return True
------------------------------------------------------------------------------
Using stack for storing the current node as a check point for the next element.
Once the current is larger than the last element in the stack, we know we should take it as the right node.
The last element poping out from the stack will be also a checking point. We will use it to validate the BST property of the current element/node.
time complexity: O(n)
space complexity: O(n)
chk, stack = None, []
for n in preorder:
while stack and n > stack[-1]:
chk = stack.pop()
if chk != None and n < chk:
return False
stack.append(n)
return True
Example 1: [5, 2, 6, 1, 3]
n = 5, stack = [5]
no checking point
Tree: 5
n = 2, 2 < 5, stack = [5, 2]
no checking point
Tree: 5
/
2
n = 6, 6 > 2, 6 > 5, stack = [6]
checking point = 5
then it is said to be an Underflow condition.
Peek or Top: Returns top element of stack.
isEmpty: Returns true if stack is empty, else false.
# Python program to
# demonstrate stack implementation
# using list
stack = []
# append() function to push
# element in the stack
stack.append('a')
stack.append('b')
stack.append('c')
print('Initial stack')
print(stack)
# pop() fucntion to pop
# element from stack in
# LIFO order
print('\nElements poped from stack:')
print(stack.pop())
print(stack.pop())
print(stack.pop())
print('\nStack after elements are poped:')