python链表、栈、队列、树

class Stack:#栈
     def __init__(self):
         self.items = []

     def isEmpty(self):
         return self.items == []

     def push(self, item):
         self.items.append(item)

     def pop(self):
         return self.items.pop()

     def peek(self):
         return self.items[len(self.items)-1]

     def size(self):
         return len(self.items)

class MinStack:#python最小栈

    def __init__(self):
        self._list=[]


    def push(self, val: int) -> None:
        self._list.append(val)
        self._min=min(self._list)


    def pop(self) -> None:
        self._list.pop()
        self._min=not self._list or min(self._list)


    def top(self) -> int:
        return self._list[-1]


    def getMin(self) -> int:
        return self._min

#链表
class Node(object):#节点
    def __init__(self):
        self.val = None
        self.next = None

class Node_handle():
    def __init__(self):
        self.cur_node = None
　　# 查找
    def find(self,node,num,a = 0):
        while node:
            if a == num:
                return node
            a += 1
            node = node.next
　　# 增加
    def add(self,data):
        node = Node()
        node.val = data
        node.next = self.cur_node
        self.cur_node = node
        return node
　　# 打印
    def printNode(self,node):
        while node:
            print ('\nnode: ', node, ' value: ', node.val, ' next: ', node.next)
            node = node.next
　  # 删除
    def delete(self,node,num,b = 1):
        if num == 0:
            node = node.next
            return node
        while node and node.next:
            if num == b:
                node.next = node.next.next
            b += 1
            node = node.next
        return node
　　# 翻转
    def reverse(self,nodelist):
        list = []
        while nodelist:
            list.append(nodelist.val)
            nodelist = nodelist.next
        result = Node()
        result_handle =Node_handle()
        for i in list:
            result = result_handle.add(i)
        return result

if __name__ == "__main__":
    l1 = Node()
    ListNode_1 = Node_handle()
    l1_list = [1, 8, 3]
    for i in l1_list:
        l1 = ListNode_1.add(i)
    ListNode_1.printNode(l1)
    l1 = ListNode_1.delete(l1,0)
    ListNode_1.printNode(l1)
    l1 = ListNode_1.reverse(l1)
    ListNode_1.printNode(l1)
    l1 = ListNode_1.find(l1,1)
    ListNode_1.printNode(l1)

import Queue
#队列
q = Queue.Queue()

for i in range(5):
    q.put(i)

while not q.empty():
    print q.get()

#coding=utf-8
class Node(object):#先获取到节点，节点有两个作用，1.进行一个指针（假设的）一个指向，
                    # 2,。就是现在这个位置上的元素的值
    def __init__(self,val):
        self.next=None  #指针的下一个，用于指向内容，先给初始化设置为空
        self.val=val   #val是它原本的值，

class Queue(object):
    def __init__(self): #初始化两个属性，分别代表first头和last
        self.first=None
        self.last=None
    def enter(self,n):  #开始进队列
        #实例节点
        n = Node(n)  # 指定在第5个位置上
        #进队列时需要先判断队列是不是空，如何判断，通过判断first是不是空
        if self.first==None:
            self.first=n  #为什么为空了还要把值赋值给first
            self.last=self.first
        else:#进队列，first不变，last的位置向后移动一个
            self.last.next=n   #指针指向后面一个  #把下移后的指向给lst.netx
            self.last=n   #赋值值给last

    def quit(self): #退出队列，
        #退出队列就是
        if self.first==None:
            return None
        else:
            tmp=self.first.val   #获取项目的值
            self.first=self.first.next
        return tmp
    def allQuit(self):#全部退出
        Lists=[] #用户保存数据
        while self.first!=None:
            Lists.append(self.first.val)  #把每一次的值存入到一个list中
            self.first=self.first.next
        return Lists

if __name__=="__main__":
    q=Queue()
    q.enter(1)
    q.enter(2)
    q.enter(3)

   # print q.quit()
   # print q.quit()
   # print q.quit()

    print q.allQuit()

class BinaryTree:#python树
    def __init__(self,rootObj):
        self.key = rootObj
        self.leftChild = None
        self.rightChild = None
 
    def insertLeft(self,newNode):
        if self.leftChild == None:
            self.leftChild = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.leftChild = self.leftChild
            self.leftChild = t
 
    def insertRight(self,newNode):
        if self.rightChild == None:
            self.rightChild = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.rightChild = self.rightChild
            self.rightChild = t
 
 
    def getRightChild(self):
        return self.rightChild
 
    def getLeftChild(self):
        return self.leftChild
 
    def setRootVal(self,obj):
        self.key = obj
 
    def getRootVal(self):
        return self.key
 
 
r = BinaryTree('a')
print(r.getRootVal())
print(r.getLeftChild())
r.insertLeft('b')
print(r.getLeftChild())
print(r.getLeftChild().getRootVal())
r.insertRight('c')
print(r.getRightChild())
print(r.getRightChild().getRootVal())
r.getRightChild().setRootVal('hello')
print(r.getRightChild().getRootVal())

具体细节讲解：python 进阶——多种数据结构的封装（链表、栈、队列、二叉树）_代码人的博客的博客-CSDN博客