栈、队列、链表、二叉树

# stack 栈  LIFO 后进先出(先进后出First In Last Out)
class Stack(object):
    def __init__(self):
        self.items = []
    #isEmpty
    def isEmpty(self):
        return self.items == []
    #push
    def append(self, item):
        self.items.append(item)
    #pop
    def pop(self):
        return self.items.pop()
    #peek
    def peek(self):
        return self.items[-1]
    #size
    def size(self):
        return len(self.items)

#queue 队列 FIFO
class Queue(object):
    def __init__(self):
        self.items = []
    def isEmpty(self):
        return self.items == []
    def enqueque(self, item):
        self.items.insert(0,item)
    def dequeque(self):
        return self.items.pop()
    def peek(self):
        return self.items[-1]
    def size(self):
        return len(size.items)

#双端队列  
class DoubleQueue(object):
    def __init__(self):
        self.items = []
    def isEmpty(self):
        return self.items == []
    def addRear(self,value):
        self.items.insert(0,value)
    def addFront(self,value):
        self.items.append(value)
    def removeFront(self):
        return self.items.pop()
    def removeRear(self):
        return self.items.pop(0)
    def size(self):
        return len(self.items)

#singly linked list  单链表
class SinglyLinkedList(object):
    def __init__(self,value):
        self.value = value
        self.nextnode = None
        
a = SinglyLinkedList(1)
b = SinglyLinkedList(2)
c = SinglyLinkedList(3)

a.nextnode = b
b.nextnode = c

#doubly linked list双链表
class DoublyLinkedList(object):
    def __init__(self,value):
        self.value = value
        self.nextnode = None
        self.prevnode = None
        
a = DoublyLinkedList(1)
b = DoublyLinkedList(2)
c = DoublyLinkedList(3)

a.nextnode = b
b.prevnode = a
b.nextnode = c
c.prevnode = b

# Tree
#1.list构建  [root, [left], [right]]
#2.class构建

#创建二叉树  
def binary_tree(r):
    return [r, [], []]

def insert_left(root,newBranch):
    t = root.pop(1)
    if len(t) > 1:
        root.insert(1, [newBranch,t,[]])
    else:
        root.insert(1,[newBranch,[],[]])
    return root

def insert_right(root,newBranch):
    t = root.pop(2)
    if len(t) > 1:
        root.insert(2, [newBranch,[],t])
    else:
        root.insert(2,[newBranch,[],[]])    
    return root

def get_root_value(root):
    return root[0]

def set_root_value(root,newvalue):
    root[0] = newvalue
    
def get_left_child(root):
    return root[1]

def get_right_child(root):
    return root[2]

# class 构建 Tree
class BinaryTree(object):
    def __init__(self,rootObj):
        self.key = rootObj
        self.leftChild = None
        self.rightChild = None
        
    def insert_leftchild(self,newbranch):
        if self.leftChild == None:
            self.leftChild = BinaryTree(newbranch)
        else:
            t = BinaryTree(newbranch)
            t.leftChild = self.leftChild
            self.leftChild = t
            
    def insert_rightchild(self,newbranch):
        if self.rightChild == None:
            self.rightChild = BinaryTree(newbranch)
        else:
            t = BinaryTree(newbranch)
            t.rightChild = self.rightChild
            self.rightChild = t
            
    def get_leftchild(self):
        return self.leftChild
    
    def get_rightchild(self):
        return self.rightChild
    
    def set_rootvalue(self,value):
        self.key = value
        
    def get_rootvalue(self):
        return self.key