def preOrderIterative(root):

    if root == None:
        return

    stack1 = MyStack()
    stack1.push(root)
    while not stack1.isEmpty():

        node = stack1.pop()
        print(node.key)

        if node.rightChild != None:
            stack1.push(node.rightChild)
        if node.leftChild != None:
            stack1.push(node.leftChild)
Exemplo n.º 2
0
def topoSort(graph):

    stack = MyStack()
    visited = set()

    for vKey in graph.vertices:

        vertex = graph.vertices[vKey]

        if vertex in visited:
            continue
        else:
            topUtil(vertex=vertex, visited=visited, stack=stack, graph=graph)

    return stack
def reverseLevelOrder(root):
    q = MyQueue()
    stack = MyStack()
    q.enqueue(root)
    q.enqueue(None)
    arr = [root.key]

    stack.push(arr)
    arr = []

    while not q.isEmpty():

        top = q.dequeue()
        if top == None and q.size() >= 1:
            """if top is None and after dequeue, queue size is 0 (q.size() >=1 is false) 

            then tree traversal is finished"""
            print("\n")

            stack.push(arr)
            arr = []

            q.enqueue(top)

        elif top:

            if top.leftChild:
                q.enqueue(top.leftChild)
                arr.append(top.leftChild.key)
            if top.rightChild:
                q.enqueue(top.rightChild)
                arr.append(top.rightChild.key)

                # q.displayAllElements()

    while not stack.isEmpty():

        arr = stack.pop()
        print(arr)
 def __init__(self):
     self.stack1 = MyStack()
     self.stack2 = MyStack()
     #self.stack1.push(ele)
     self.currentStack = self.stack1
class queue():
    def __init__(self):
        self.stack1 = MyStack()
        self.stack2 = MyStack()
        #self.stack1.push(ele)
        self.currentStack = self.stack1

    def enqueue(self, ele):
        if self.currentStack == self.stack1:

            self.stack1.push(ele)
        else:
            while not self.stack2.isEmpty():
                self.stack1.push(self.stack2.pop())
            self.currentStack = self.stack1
            self.stack1.push(ele)
        self.displayAllElement()

    def dequeue(self):

        if self.currentStack == self.stack2:
            self.stack2.pop()
        else:
            while not self.stack1.isEmpty():
                self.stack2.push(self.stack1.pop())

            self.currentStack = self.stack2
            self.stack2.pop()
        self.displayAllElement()

    def getSize(self):

        return self.currentStack.size()

    def displayAllElement(self):

        if self.currentStack == self.stack1:
            self.stack1.displayAllElements()
        else:
            self.stack2.displayAllElementsInReverseOrder()
def check_Balance_Parant(str):

    # Check is even number of brackets
    if len(str) % 2 != 0:
        return False

    stack = MyStack()

    for s in str:

        if s == '{' or s == '[' or s == '(':
            stack.push(s)
        else:

            if s == ')' and stack.peek() == '(':
                stack.pop()
            elif s == '}' and stack.peek() == '{':
                stack.pop()
            elif s == ']' and stack.peek() == '[':
                stack.pop()
            else:
                return False

    if stack.isEmpty():
        return True
    else:
        return False
Exemplo n.º 7
0
            if child.color != Color.Grey:
                dfsRec(graph, child)
        return
    else:
        return


g = Graph()
g.addVertex("A")
g.addVertex("B")
g.addVertex("C")
g.addVertex("D")
g.addVertex("E")
g.addVertex("F")
g.addVertex("G")
g.addVertex("Z")

g.addEdge(fromVertex="A", toVertex="B", weight=50)
g.addEdge(fromVertex="A", toVertex="F", weight=50)
g.addEdge(fromVertex="B", toVertex="C", weight=50)
g.addEdge(fromVertex="B", toVertex="Z", weight=50)
g.addEdge(fromVertex="C", toVertex="D", weight=50)
g.addEdge(fromVertex="D", toVertex="E", weight=50)
g.addEdge(fromVertex="F", toVertex="G", weight=50)
g.addEdge(fromVertex="G", toVertex="H", weight=50)

stack = MyStack()
#dfs(g,g.vertices["A"],stack)

dfsRec(g, g.vertices["A"])