Python数据结构与算法

1、栈结构的实现

class Stack(object):
    """栈操作"""
    def __init__(self):
        self.__list = []

    def push(self,item):
        """
        添加一个新元素item到栈顶
        :param item:
        :return:
        """
        self.__list.append(item)

    def pop(self):
        """弹出栈顶元素"""
        return self.__list.pop()

    def peek(self):
        """返回栈顶元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        """判断栈是否为空"""
        return self.__list == []

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

if __name__ == "__main__":
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    print(s.pop())
    print(s.pop())
    print(s.pop())

2、队列的操作

class queue(object):
    """队列"""
    def __init__(self):
        self.__list = []

    def enqueue(self,item):
        """往队列里添加一个item元素"""
        self.__list.append(item)

    def dequeue(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

    def is_empty(self):
        """判断是否为空"""
        return self.__list == []

    def size(self):
        """返回队列大小"""
        return len(self.__list)

if __name__ == "__main__":
    q = queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    print(q.dequeue())
    print(q.dequeue())
    print(q.dequeue())

3、双向队列

class muldeque(object):
    def __init__(self):
        self.__list = []

    def add_front(self,item):
        """往队列里添加一个item元素"""
        self.__list.insert(0,item)

    def add_rear(self,item):
        self.__list.append(item)

    def pop_front(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

    def pop_rear(self):
        return self.__list.pop()

    def is_empty(self):
        """判断是否为空"""
        return self.__list == []

    def size(self):
        """返回队列大小"""
        return len(self.__list)

if __name__ == "__main__":
    q = muldeque()
    q.add_front(1)
    q.add_front(2)
    q.add_front(3)
    q.add_rear(100)
    q.add_rear(99)
    q.add_rear(98)
    print(q.pop_front())
    print(q.pop_rear())

4、树结构

• 无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树；
• 有序树：树中任意节点的子节点之间有顺序关系，这种树称为有序树；
• 二叉树：每个节点最多含有两个子树的树称为二叉树；
  • 完全二叉树：对于一颗二叉树，假设其深度为d(d>1)。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树，其中满二叉树的定义是所有叶节点都在最底层的完全二叉树;
  • 平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；
  • 排序二叉树（二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树）；
• 霍夫曼树（用于信息编码）：带权路径最短的二叉树称为哈夫曼树或最优二叉树；
• B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多余两个子树。

class Node(object):
    """节点类"""
    def __init__(self,item):
        self.elem = item
        self.lchild = None
        self.rchild = None

class Tree(object):
    """二叉树"""
    def __init__(self):
        self.root = None

    def add(self,item):
        """
        为树添加节点
        :param item:
        :return:
        """
        node = Node(item)
        # 如果树是空的，则对根节点赋值
        if self.root is None:
            self.root = node
            # 返回空值
            return
        else:
            queue = []
            queue.append(self.root)
            while queue:
                # 弹出队列的第一个元素
                cur_node = queue.pop(0)
                if cur_node.lchild == None:
                    cur_node.lchild = node
                    return
                else:
                    # 如果不为空，则加入左子树继续判断
                    queue.append(cur_node.lchild)
                if cur_node.rchild == None:
                    cur_node.rchild = node
                    return
                else:
                    # 如果不为空，则加入右子树继续判断
                    queue.append(cur_node.rchild)

    def breadth_travel(self):
        """广度遍历"""
        # 如果树为空
        if self.root is None:
            return
        # 树不为空时，首先遍历根节点，然后遍历左子树，右子树
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem,end = "\t")
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)
    def preorder(self,node):
        """先序，根左右"""
        if node is None:
            return
        print(node.elem,end = " ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):
        """中序，左根右"""
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem, end=" ")
        self.inorder(node.rchild)

    def postorder(self,node):
        """后序，左右根"""
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem, end=" ")





if __name__ == "__main__":
    tree = Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)

    tree.breadth_travel()
    print("\t")
    print("*************************")
    tree.preorder(tree.root)
    print("\t")
    print("*************************")
    tree.inorder(tree.root)
    print("\t")
    print("*************************")
    tree.postorder(tree.root)