Python stack.Stack类代码示例

def main():
    my_stack = Stack() 
    for _ in range(10):
        my_stack.push(randint(0, 9))
    sort_stack(my_stack)
    for _ in range(10):
        print my_stack.pop()

def converter(exp, fix="post"):
    """takes simple infix expression and converts to prefix or postfix"""
    tokens = list(exp)
    open_paren, close_paren = "(", ")"

    if fix not in ["pre", "post"]:
        raise ValueError("Must specify conversion as either 'pre' or 'post'")

    if fix == "pre":
        tokens.reverse()
        open_paren, close_paren = ")", "("

    s = Stack()
    result = ''

    for t in tokens:
        if t == open_paren:
            pass
        elif t in ["*", "+", "-", "/"]:
            s.push(t)
        elif t == close_paren and not s.is_empty():
            result += s.pop()
        else:
            result += t

    if fix == "pre":
        return result[::-1]
    return result

 def __init__(self):
     ''' 
     Initialize the queue with two stacks -- an incoming
     and outgoing stack.
     '''
     self.incoming_stack = Stack()
     self.outgoing_stack = Stack()

def heightStack(height, nameStr):
    h = Stack(nameStr)
    while height != 0:
        h.push(height)
        height -= 1

    return h

	def solution(self):
		stck = Stack()
		node = self.goal
		while not node is None:
			stck.push(node.board)
			node = node.prev
		return stck

def test_push_pop(input_list):
    from stack import Stack
    new_stack = Stack()
    for item in input_list:
        new_stack.push(item)
    for item in reversed(input_list):
        assert new_stack.pop() == item

def test_pop_2():
    our_list = ["first", "second", "third", "fourth"]
    our_stack = Stack(our_list)
    assert our_stack.pop() == "fourth"
    assert our_stack.pop() == "third"
    assert our_stack.pop() == "second"
    assert our_stack.pop() == "first"

	def __init__(self):
		'''
		Initialize Queue

		'''
		self.stack1 = Stack()
		self.stack2 = Stack()

def test_count(COUNT_LIST, count):
    """Test to see if stack count is correct."""
    from stack import Stack
    s = Stack()
    for i in COUNT_LIST:
        s.push(i)
    assert s.size() == count

def test_push():
    my_stack = Stack([1, 2, 3])
    my_stack.push(4)
    # assert my_stack.container.display() == (4, 3, 2, 1)
    assert my_stack.pop() == 4
    # check to make sure new stack wasn't initialized
    assert my_stack.pop() == 3

def test_empty():
    """Test case where an empty list is pushed to stack."""
    from stack import Stack
    stacky = Stack()
    stacky.push([])
    with pytest.raises(IndexError):
        stacky.pop().get_data()

def stack_sort(s):
    def find_max(s):
        t = Stack()
        m = None
        while s.size > 0:
            v = s.pop()
            t.push(v)
            if not m or v > m:
                m = v
        while t.size > 0:
            v = t.pop()
            if v != m:
                s.push(v)
        return m

    sort = Stack()

    while s.size > 0:
        m = find_max(s)
        sort.push(m)

    while sort.size > 0:
        s.push(sort.pop())

    return s

def test_push():
    """Test stack push method."""
    from stack import Stack
    from stack import Node
    stack = Stack()
    stack.push(data[0])
    assert isinstance(stack.head, Node)

class VisitOrder:
  
    stack = None 
    level = 0

    node_list = []

    def __init__( self ):
        self.stack = Stack()

    def make_stack( self ):
        while self.stack.length() > 0:
            print "self.stack.length() ==> " + str( self.stack.length() )
            print "Pop the stack ---> " + str( self.stack.pop().value )

    def get_node( self, node_id ):
        for n in self.node_list:
            #print 'get_node ' + str( n.id )
            if n.id == node_id:
                return n
        return None

    def build_tree( self, node ):
         self.level = self.level + 1
         print "in build_tree level : " + str( self.level )
         while len( node.value ) > 0:
             node.left = self.stack.pop() 
             build_tree( node.left )
         
         while len( node.value ) > 0:
             node.right = self.stack.pop()
             build_tree( node.right )

class MyQueue:
    def __init__(self):
        self.stack_in  = Stack()
        self.stack_out = Stack()

    def enqueue(self, item):
        if not self.stack_in.is_empty():
            self.empty_stack(self.stack_in, self.stack_out)
        self.stack_in.push(item)

    def dequeue(self):
        if not self.stack_out.is_empty():
            self.empty_stack(self.stack_out, self.stack_in)
        return self.stack_in.pop()

    def empty_stack(self, stack1, stack2):
        '''
        Empty stack1 into stack2
        '''
        while not stack1.is_empty():
            stack2.push(stack1.pop())

    def print_mq(self):
        self.empty_stack(self.stack_in, self.stack_out)
        print self.stack_out