def is_balanced(string): """Check if string of parenthesis is valid.""" """Reverse string and use stack, in accordance with assignment.""" rev = string[::-1] parens = Stack() for i in rev: parens.push(i) count = 0 for i in range(parens.__len__()): p = parens.pop() if p == '(': count += 1 elif p == ')': count -= 1 if count < 0: break if count == 0: return 'balanced' elif count >= 1: return 'open' else: return 'broken'
def is_paranthesis_balanced(s): open_bkt = ['(', '[', '{', '<'] matches = [('{', '}'), ('[', ']'), ('(', ')'), ('<', '>')] stack = Stack(len(s)) for i in s: if i in open_bkt: stack.push(i) else: if stack.__len__() == 0: return False last_bkt = stack.pop() if (last_bkt, i) not in matches: return False return stack.__len__() == 0
def dft_print(self, node): stack = Stack() if self: stack.push(self) while stack.__len__() > 0: current_node = stack.pop() print(current_node.value) if current_node.right != None: stack.push(current_node.right) if current_node.left != None: stack.push(current_node.left)
def dft_print(self, node): dft_stack = Stack() dft_stack.push(node) while dft_stack.__len__() != 0: current_node = dft_stack.pop() if current_node.left is not None: dft_stack.push(current_node.left) if current_node.right is not None: dft_stack.push(current_node.right) print(current_node.value)
def dft_print(self, node): # Set up the stack the_stack = Stack() the_stack.push(node) while the_stack.__len__() > 0: # While there is anything in the stack current_node = the_stack.pop() # Pop off the top of the stack print(current_node.value) # Print the value of the popped node if current_node.left: # Check if there's a left branch the_stack.push(current_node.left) # Add it to the stack if current_node.right: # Check if there's a right branch the_stack.push(current_node.right) # Add it to the stack
def test_length(self): # Arrange my_stack = Stack() my_stack.push(1) my_stack.push(2) # Act len1 = my_stack.__len__() # Assert self.assertEqual(2, len1, "length did not have the expected value")
def dft_print(self, node): # create a stack for nodes stack = Stack() # add the first node to the stack stack.push(node) # while the stack is not empty while stack.__len__() != 0: # get the current node from the top of the stack removed = stack.pop() # print that node print(removed.value) # add all children to the stack if removed.right is not None: stack.push(removed.right) if removed.left is not None: stack.push(removed.left)
def dft_print(self, node): # Initialize empty stack # Push the root node onto the stack stack = Stack() stack.push(node) # Need a while loop to manage iteration # If stack is not empty enter the while loop while stack.__len__() > 0: # pop top item off stack # print items value current = stack.pop() print(current.value) # if there is left subtree if current.left is not None: stack.push(current.left) # push left item onto stack # if there is right subtree if current.right is not None: stack.push(current.right)
def dequeue(self): self.size -= 1 if not self.head: return None else: value = self.head.get_value() self.head = self.head.get_next() return value print(Stack) b = Stack() l = Queue() b.push(100), "Length:", b.__len__() b.push(101), "Length:", b.__len__() b.push(102), "Length:", b.__len__() b.push(103), "Length:", b.__len__() l.enqueue(100) l.enqueue(101) l.enqueue(105) l.enqueue(4) print(l.dequeue(), "Length:", l.__len__()) print(l.dequeue(), "Length:", l.__len__()) print(l.dequeue(), "Length:", l.__len__()) print(l.dequeue(), "Length:", l.__len__()) print(l.dequeue(), "Length:", l.__len__())
def test_len(): s = Stack() value = s.__len__() assert value == 0