面向对象案例：栈与队列的封装，二叉树

一.栈和队列的封装

1.栈

• 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈）。
• 栈顶：允许进行操作的一端，栈底： 另一固定端，空栈： 当栈中没有元素时。
• push: 向一个栈插入元素称为进栈；
• pop: 从一个栈删除元素称为是出栈。
• 栈的特点：后进先出（LIFO）
  
  案例：

class Stack(object):
    """
    根据列表的数据结构封装栈的数据结构
    属性：栈元素 stack
    方法：获取栈顶元素： get_top()
          获取栈底元素：get_bottom()
          入栈：push()
          出栈：pop()
    """
    def __init__(self):
        self.stack=[]
    def get_top(self):
        return self.stack[-1]
    def get_bottom(self):
        return self.stack[0]
    def push(self,item):
        self.stack.append(item)
        return True
    def pop(self):
        item=self.stack.pop()
        return item
    def show(self):
        return self.stack
    #定义魔术方法，获取长度
    def __len__(self):
        return len(self.stack)  #stack是一个列表，所以这里用len()
#实例化对象
if __name__ == '__main__':
    st=Stack()
    print(st.show())
    st.push(1)
    st.push(3)
    st.push(7)
    print('入栈后：',st.show())
    item=st.pop()          #这里注意要将出栈的元素赋值给一个变量
    print('出栈元素为：',item)
    print('出栈后：',st.show())
    print('栈的长度为：',st.__len__())
    print('栈顶元素为：',st.get_top())
    print('栈底元素为：',st.get_bottom())

运行结果

[]
入栈后： [1, 3, 7]
出栈元素为： 7
出栈后： [1, 3]
栈的长度为： 2
栈顶元素为： 3
栈底元素为： 1

2.队列

• 队列是限制在一端进行插入操作和另一端删除操作的线性表
• 允许进行插入操作的一端称为队尾，允许进行删除操作的一端称为队头
• 当队列中没有元素时称为空队
• 队列的特点是：先进先出（FIFO）
  

class queue(object):
    """
    根据队列的数据结构封装队列的数据结构
    属性：队列元素 queue
    方法：获取队首元素：get_first()
          获取队尾元素：get_last()
          入队：enqueue()
          出队：dequeue()
    """
    def __init__(self):
        self.queue=[]
    def get_first(self):
        return self.queue[0]
    def get_last(self):
        return self.queue[-1]
    def enqueue(self,item):
        self.queue.append(item)
        return True
    def dequeue(self):
        item=self.queue.pop()
        return item
    def show(self):
        return self.queue
    def __len__(self):
        return len(self.queue)
if __name__ == '__main__':
    q=queue()
    print(q.show())
    q.enqueue(2)
    q.enqueue(5)
    q.enqueue(9)
    print('入队后：',q.show())
    item=q.dequeue()
    print('出队的元素：',item)
    print('出队后：',q.show())
    print('队首为：',q.get_first())
    print('队尾为：',q.get_last())
    print('队的长度为：',q.__len__())

运行结果

[]
入队后： [2, 5, 9]
出队的元素： 9
出队后： [2, 5]
队首为： 2
队尾为： 5
队的长度为： 2

二.二叉树的实现和遍历

• 二叉树是每个结点最多有两个子树的树结构

• 通常子树被称为左子树（left child）和右子树（right child）

• 每个结点分为三部分：data,lchild,rchild
  

• 先序遍历：根左右

• 中序遍历：左根右

• 后序遍历：左右根

class Node(object):
    def __init__(self,data,lchild=None,rchild=None):
        self.data=data
        self.lchild=lchild
        self.rchild=rchild
    #定义魔术方法，使str()成为我们自己定义的类函数中的内置函数
    def __str__(self):
        return str(self.data)
#先序遍历
def pre_view(root):
    if root==None:
        return
    print(root.data)
    pre_view(root.lchild)
    pre_view(root.rchild)
#后序遍历
def last_view(root):
    if root==None:
        return
    last_view(root.lchild)
    last_view(root.rchild)
    print(root.data)
#中序遍历
def mid_view(root):
    if root==None:
        return
    mid_view(root.lchild)
    print(root.data)
    mid_view(root.rchild)
if __name__ == '__main__':
    D=Node('D')
    B=Node('B',D)
    C=Node('C')
    A=Node('A',B,C)
    print('A-lchild:',str(A.lchild))
    print('A-rchild:',str(A.rchild))

    print('先序遍历：')
    pre_view(A)
    print('后序遍历')
    last_view(A)
    print('中序遍历：')
    mid_view(A)

运行结果

A-lchild: B
A-rchild: C
先序遍历：
A
B
D
C
后序遍历
D
B
C
A
中序遍历：
D
B
A
C