节点操作总结

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