def iter_dfs(self, v):
"""
시작 정점으로 돌아가
더 이상 방문할 정점이 없어야 종료
"""
s = Stack()
self.init_visited()
s.push(v)
#방문 체크 및 방문
self.visited[v] = True
print(v, end=" ")
#아직 방문하지 않은 정점을 방문했는가
is_visited = False
while not s.empty():
is_visited = False
v = s.peek()
#인접 리스트를 받아온다.
u = self.adjacency_list[v]
while u:
if not self.visited[u.vertex]:
s.push(u.vertex)
#방문 체크 및 방문
self.visited[u.vertex] = True
print(u.vertex, end=" ")
#아직 방문하지 않은 정점을 방문했으므로
is_visited = True
break
u = u.link
if not is_visited:
s.pop()
def print_num_use_stack(n):
from stack1 import Stack
s = Stack()
while n > 0:
s.push(n)
n -= 1
while not s.is_empty():
print(s.pop())
def div_by_2(dec_num):
s = Stack()
while dec_num > 0:
rem = dec_num % 2
s.push(rem)
dec_num = dec_num // 2
bin_num = ""
while not s.is_empty():
bin_num += str(s.pop())
return bin_num
def parChecker(symbolString):
s = Stack()
balanced = True
index = 0
while index < len(symbolString) and balanced:
symbol = symbolString[index]
if symbol == "(":
s.push(symbol)
else:
if s.isEmpty():
balanced = False
else:
s.pop()
index = index + 1
if balanced and s.isEmpty():
return True
else:
return False
def getBinary_num(num,base):
s = Stack()
while(num > 0):
a = num%base
s.push(a)
num = num/base
st = ""
while not s.isEmpty():
st += str(s.pop())
return st
def parChecker2(symbolString):
s = Stack()
balanced = True
index = 0
while index < len(symbolString) and balanced:
symbol = symbolString[index]
if symbol in "([{":
s.push(symbol)
else:
if s.isEmpty():
balanced = False
else:
top = s.pop()
if not matches(top, symbol):
balanced = False
index = index + 1
if balanced and s.isEmpty():
return True
else:
return False
def is_parent_balanced(paren_string):
s = Stack()
is_balanced = True
index = 0
while index < len(paren_string) and is_balanced:
paren = paren_string[index]
if paren in "({[":
s.push(paren)
else:
if s.is_empty():
is_balanced = False
else:
top = s.pop()
if not is_match(top, paren):
is_balanced = False
index += 1
if s.is_empty() and is_balanced:
return True
else:
return False
def check_brackets(statement):
stack = Stack()
last = stack.pop()
for ch in statement:
if ch in ('{', '[', '('):
stack.push(ch)
if ch in ('}', ']', ')'):
last = stack.pop()
if last is '{' and ch is '}':
continue
elif last is '[' and ch is ']':
continue
elif last is '(' and ch is ')':
continue
else:
return False
if stack.size > 0:
return False
else:
return True
from stack1 import Stack
def reverse(s):
for i in range(len(s)):
stack.push(s[i])
rev = ''
while not stack.isempty():
rev += stack.pop()
return rev
stack = Stack()
s = input()
print(reverse(s))
from stack1 import Stack
print('Enter the string')
string = input()
s = Stack()
for char in string:
s.push(char)
print("Reversing string")
while not s.isEmpty():
print(s.pop(), end="")
from stack1 import Stack
s = Stack()
def parchecker(l):
balanced = True
i = 0
while i < len(l) and balanced == True:
if l[i] in '([{':
s.push(l[i])
else:
if s.isempty():
balanced = False
else:
top = s.pop()
if not matches(top, l[i]):
balanced = False
i += 1
if balanced == True:
return True
else:
return False
def matches(open, close):
opens = '{[('
closer = ')]}'
return opens.index(open) == closer.index(close)
print(parchecker('{{[[(())]]}}'))
def setUp(self):
self.stack = Stack()
class QueueTests(unittest.TestCase):
def setUp(self):
self.stack = Stack()
def test_len_returns_0_for_empty_stack(self):
self.assertEqual(len(self.stack), 0)
def test_len_returns_correct_length_after_push(self):
self.assertEqual(len(self.stack), 0)
self.stack.push(2)
self.assertEqual(len(self.stack), 1)
self.stack.push(4)
self.assertEqual(len(self.stack), 2)
self.stack.push(6)
self.stack.push(8)
self.stack.push(10)
self.stack.push(12)
self.stack.push(14)
self.stack.push(16)
self.stack.push(18)
self.assertEqual(len(self.stack), 9)
def test_empty_pop(self):
self.assertIsNone(self.stack.pop())
self.assertEqual(len(self.stack), 0)
def test_pop_respects_order(self):
self.stack.push(100)
self.stack.push(101)
self.stack.push(105)
self.assertEqual(self.stack.pop(), 105)
self.assertEqual(len(self.stack), 2)
self.assertEqual(self.stack.pop(), 101)
self.assertEqual(len(self.stack), 1)
self.assertEqual(self.stack.pop(), 100)
self.assertEqual(len(self.stack), 0)
self.assertIsNone(self.stack.pop())
self.assertEqual(len(self.stack), 0)
from stack1 import Stack
from nodes1 import Node
class TreeNode:
def __init__(self, data):
self.data = data
self.right = None
self.left = None
expr = "4 5 + 5 3 - *".split()
stack = Stack()
for term in expr:
if term in "+-*/":
node = TreeNode(term)
node.right = stack.pop()
node.left = stack.pop()
else:
node = TreeNode(int(term))
stack.push(node)
def calc(node):
if node.data is "+":
return calc(node.left) + calc(node.right)
elif node.data is "-":
return calc(node.left) - calc(node.right)
elif node.data is "/":
return calc(node.left) / calc(node.right)
elif node.data is "*":