节点操作总结

Stack 添加元素

 def push( self, newValue ):
        self.top = LinkedNode( newValue, self.top )

队列添加元素

def enqueue( self, newValue ):
        newNode = LinkedNode( newValue )
        if self.front == None:
            self.front = newNode
        else:
            self.back.link = newNode
        self.back = newNode

链表加入

def prepend( self, new_value ):
        self.__front = LinkedNode( new_value, self.__front )

插入

链表
def insert( self, cursor, new_value ):
        if cursor == self.__front:
            self.prepend( new_value )
        else:
            node = self.__front
            while node.link != cursor:
                node = node.link
            node.link = LinkedNode( new_value, cursor )

链表
def append( self, new_value ):
        node = self.__front
        newNode = LinkedNode( new_value )
        if node == None:
            self.__front = newNode
        else:
            while node.link != None:
                node = node.link
            node.link = newNode

树
def __insert(self, val, node):
        if val < node.val:                     # check if need to go left
            if node.left == None:              # if no left child
                node.left = BTNode(val)        # insert it here
            else:                              # otherwise 
                self.__insert(val, node.left)  # traverse with the left node
        else:                                  # need to go right
            if node.right == None:             # if no right child
                node.right = BTNode(val)       # insert it here                               
            else:                              # otherwise 
                self.__insert(val, node.right) # traverse with the right node

    def insert(self, val): 
        if self.root == None:              # if tree is empty
            self.root = BTNode(val)        # create root node with the value
        else:                              # otherwise
            self.__insert(val, self.root)  # call helper function with root
        self.size += 1

出队列

def dequeue( self ):
        assert not self.isEmpty(), "Dequeue from empty queue"
        self.front = self.front.link
        if self.front == None:
            self.back = None

是否为空

队列
def isEmpty( self ):
        return self.front == None

栈
def isEmpty( self ):
        return self.top == None

去除掉第一个

栈
def pop( self ):
        assert not self.isEmpty(), "Pop from empty stack"
        self.top = self.top.link

得到第一个

 队列
 def peek( self ):
        assert not self.isEmpty()
        return self.front.value

 栈
 def peek( self ):
        assert not self.isEmpty(), "peek on empty stack"
        return self.top.value