【栈、队列与二叉树】

目录

一、栈是什么？

二、栈结构的实现

三、队列是什么？

四、队列的实现

五、树和二叉树

六、二叉树的实现

一、栈是什么？

1.栈(stack)，有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素

2.特点：只能允许在容器的一端(称为栈顶端指标—— top) 进行加入数据(push)和输出数据(pop) 的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。
3.由于栈数据结构只允许在一端进行操作，因而按照先进后出（后进先出）的原理运作。

二、栈结构的实现

 

 1.实现步骤：

（1）Stack()创建一个新的空栈

（2）push(item)添加一个新的元素item到栈顶

（3）pop()弹出栈顶元素

（4）peek()返回栈顶元素

（5）is_empty()判断栈是否为空

（6）size()返回栈的元素个数

2.代码实现：

class Stack(object):
    #定义初始化方法
    def __init__(self):
        #初始化一个空列表
        self._list=[]
    #压栈
    def push(self,item):
        self._list.append(item)

    #弹出元素
    def pop(self):
        return self._list.pop()

    #返回栈顶元素
    def peek(self):
        return self._list[len(self._list)-1]

    #判断栈顶是否为空
    def is_empty(self):
        return self._list==[]

    #计算栈的大小
    def size(self):
        return len(self._list)
if __name__=="__main__":
    stack=Stack()
    print("栈是否为空：",stack.is_empty())
    #压栈
    stack.push(1)
    stack.push(2)
    stack.push(3)
    stack.push(4)
    print("栈是否为空：",stack.is_empty())
    print("栈的长度：",stack.size())
    #弹出
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())

栈是否为空： True
栈是否为空： False
栈的长度： 4
4
3
2
1

三、队列是什么？

1.队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

2.队列是遵循先进先出的原理简称，允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作。假设队列是q= (a1,a2,..... an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。

四、队列的实现

1.实现步骤：

（1）Queue()创建一个空的队列

（2）enqueue(item)向队列中添加元素item

（3）dequeue()从队列头部删除一个元素

（4）is_empty判断一个队列是否为空

（5）size()返回队列大小

2.代码实现：

class Queue(object):
    #定义初始化方法
    def __init__(self):
        self._list=[]
    #进队
    def enqueue(self,item):
        #self._list.append(item)
        self._list.insert(0,item)
    #出队
    def dequeue(self):
        #return self._list.pop()
        return self._list.pop()
    #判断是否为空
    def is_empty(self):
        return self._list==[]
    #计算队列大小
    def size(self):
        return len(self._list)

if __name__=="__main__":
    queue=Queue()
    print("队列是否为空：",queue.is_empty())
    #进队
    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)
    print("队列是否为空：", queue.is_empty())
    #出队
    print(queue.dequeue())
    print(queue.dequeue())
    print(queue.dequeue())

队列是否为空： True
队列是否为空： False
1
2
3

五、树和二叉树

1.树的相关概念：

树( tree) 是一种抽象数据类型(ADT)或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n (n>=1)个有限节点组成的一个具有层次关系的集合。

2.树的相关术语： 

（1）节点的度:一个节点含有的子树的个数称为该节点的度
（2）树的度: 一棵树中，最大的节点的度称为树的度
（3）叶节点或终端节点:度为零的节点
（4）父节点:若一个节点含有子节点，则这个节点称为其子节点的父节点 

3.树的相关性质：

(1)每个节点有零个或多个子节点
(2)没有父节点的节点称为根节点
(3)每一个非根节点有且只有一个父节点
(4)除了根节点外，每个子节点可以分为多个不相交的子树 

4..二叉树的概念：二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。

5.二叉树分类：

（1）完全二叉树:对于一颗二叉树，假设其深度为d(d>1)，除了第d层外，其它各
层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列

（2）满二叉树：所有叶节点都在最底层的完全二叉树
（3）平衡二叉树(AVL树) :当且仅当任何节点的两棵子树的高度差不大于1的二叉树
（4）排序二叉树(二叉查找树)，也称二叉搜索树、有序二叉树)

 6.二叉树的性质：

（1）在二叉树的第i层上至多有2^(i-1)个节点(i>0)

（2）深度为k的二叉树至多有2^k-1个节点(k>0)
（3）对于任意一棵二叉树，如果其叶节点数为N0，而度数为2的结点总数为N2,则N0=N2+1
（4）具有n个节点的完全二叉树的深度必为log2(n+1)
（5）对完全二叉树，若从上至下、从左至右编号，则编号为i的结点，其左孩子编号必为2i，其右孩子编号必为2i+1;其双亲的编号必为i/2 (i=1 时为根，除外)

六、二叉树的实现

#定义二叉树节点
class Node:
    def __init__(self,elem):
        self.elem=elem
        self.Ichild=None
        self.Rchild=None

class Tree:
    def __init__(self):
        self.root=None
    #添加节点
    def add(self,elem):
        #创建节点
        node=Node(elem)
        if self.root==None:
            self.root=node
        else:
            queue=[]
            queue.append(self.root)
            while queue:
                curNode=queue.pop(0)
                if curNode.Ichild==None:
                    curNode.Ichild=node
                    return
                else:
                    queue.append(curNode.Ichild)
                if curNode.Rchild==None:
                    curNode==node
                    return
                else:
                    queue.append(curNode.Rchild)
    #广度优先遍历
    def travel(self):
        queue = []
        #判断根节点是否存在
        if self.root is None:
            return
        else:
            queue.append(self.root)
        while queue:
            curNode=queue.pop(0)
            print(curNode.elem,end="\t")
            if curNode.Ichild is not None:
                queue.append(curNode.Ichild)
            if curNode.Rchild is not None:
                queue.append(curNode.Rchild)
    #先序遍历：根 左 右
    def preOrder(self,root):
        if root is None:
            return
        else:
            print(root.elem,end="\t")
            self.preOrder(root.Ichild)
            self.preOrder(root.Rchild)
    #中序遍历 左 根 右
    def inOrder(self,root):
        if root is None:
            return
        else:
            self.inOrder(root.Ichild)
            print(root.elem, end="\t")
            self.inOrder(root.Rchild)
    #后序遍历 左 右 根
    def lastOrder(self,root):
        if root is None:
            return
        else:
            self.lastOrder(root.Ichild)
            self.lastOrder(root.Rchild)
            print(root.elem, end="\t")
if __name__=="__main__":
    tree=Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    print("广度优先遍历")
    tree.travel()
    print("先序遍历")
    tree.preOrder(tree.root)
    print("中序遍历")
    tree.inOrder(tree.root)
    print("后序遍历")
    tree.lastOrder(tree.root)