Python实现常用的逻辑数据结构

逻辑数据结构包括：线形结构、树形结构、图形结构、集合；存储结构包括：顺序存储、链式存储、索引存储、散列存储。

同一种逻辑结构可以有四种存储结构，不同的存储结构增、删、查、改的速度不同。逻辑结构与存储结构排列组合，就得到4*4=16种结构。

在C/C++中，栈和队列的常用实现方式为数组和链表，存储方式分别是：顺序存储和链式存储。

在Python中，栈和队列的常用实现方式为list，存储方式是索引，实现起来要比C/C++简单的多，而且大小可以动态扩展，存取也非常方便，可以说它集成了顺序存储

和链式存储的优点，索引表本身就是顺序存储啊，就是数组，它是怎样实现动态扩展长度的呢？这个就不知道了，有空看看Python的实现代码源代码。Python也是可以

用链式存储实现线性结构的，见下面的代码，但没有list实现方便。C/C++中的内置类型（类）中没有索引存储的，你也许想到指针数组，的确，它是一种索引结构，但用

它不容易实现线性结构，因为当你添加元素时，要先用变量创建该元素，而且变量名与线性表中已有元素的变量名不能相同，每次添加都要用不同的变量名，看来这种方

式不行，那我们可以动态molloc，用指针指向该molloc，然后通过指针给新元素赋值，然后再把指针指向的地址保存在链表数组中，这样是可以，但太麻烦了。在Python

中，编程语言自动帮你实现了这个过程，这对用户来说就简单的一比了。总得来说，用list实现栈和队列和两种方法，一种是实例对象的数据属性是list，另一种是类直接

继承list类。第二种方法简单，但由于继承了list，而list提供了很多对外接口，如extend()等，这些接口其实是标准栈不应该有的。所以建议用第一种方法实现。

Stack类--实现1（推荐）

class Stack(list):
    def __init__(self):
        self.__stack = []

    def is_empty(self):
        return not bool(len(self))

    def push(self,data):
        self.__stack.append(data)
    
    def pop(self):
        if len(self.__stack)>0:
            return self.__stack.pop()

    def peek(self):
        if len(self.__stack)>0:
            return self.__stack[-1]

    def get_length(self):
        return len(self.__stack)

Stack类--实现2（不建议使用）

 class Stack(list):
     def is_empty(self):
         return not bool(len(self))
  
     def push(self,data):
         self.append(data)
  
     def pop(self):
         if len(self)>0:
             return self.pop()
 
     def peek(self):
         if len(self)>0:
             return self[-1]
 
     def get_length(self):
         return len(self)

Stack类--实现3（链式存储，不建议使用）

class Node(object):
    def __init__(self,data):
        self.data = data
        self.next = None


class Stack(object):
    def __init__(self,head_node):
        self.top = head_node
        self.bottom = head_node

    def push(self,node):
        node.next = self.top
        self.top = node

    def pop(self):
        if self.top == None:
            return None
        else:
            key = self.top
            self.top = self.top.next
            if self.top == None:
                self.bottom = None
            return key


s = Stack(Node(12))
s.push(Node(13))
s.push(Node(15))
s.push(Node(18))
s.push(Node(2))
while True:
    a = s.pop()
    if a != None:
        print a.data
        continue
    else:
        break

Queue类--实现1（推荐）

class Queue(object):
    def __init__(self):
        self.__queue = []

    def is_empty(self):
        return not bool(len(self.__queue))

    def peek(self):
        if len(self.__queue)>0:
            return self.__stack[0]
    
    def enqueue(self,node):
        self.__queue.append(node)

    def dequeue(self):
        if len(self.__queue)>0:
            return self.__queue.pop(0)

    def get_length(self):
        return len(self.__queue)

Queue类--实现2（不建议使用）

class Queue(list):
    def is_empty(self):
        return not bool(len(self))

    def peek(self):
        if len(self)>0
            return self[0]
    
    def enqueue(self,node):
        self.append(node)

    def dequeue(self,node):
        if len(self)>0:
            return self.pop(0)

    def get_length(self):
        return len(self)

BST类（二叉树类）

我们一般很少用一般二叉树，而是用进一步约束的二叉树，如二叉搜索树、红黑树等，这些树是一般二叉树的子类，

所以二叉树有的方法，这些方法都可以有。

class Node(object):
    def __init__(self,data):
        self.data = data
        self.__left =  None
        self.__right = None
        self.__parent = None
    
    @property
    def left(self):
        return self.__left
    
    @left.setter
    def left(self,node):
        if node is None or type(node) is Node:
            self.__left = node
            if type(node) is Node:
                node.parent = self
        else:
            raise Exception,'left node must be None or Node type'    
    
    @property
    def right(self):
        return self.__right
    
    @right.setter
    def right(self,node):
        if node is None or type(node) is Node:
            self.__right = node
            if type(node) is Node:
                node.parent = self
        else:
            raise Exception,'right node must be None or Node type' 

    @property
    def parent(self):
        return self.__parent
    
    @parent.setter
    def parent(self,node):
        if node is None or type(node) is Node:
            self.__parent = node
        else:
            raise Exception,'parent node must be None or Node type' 

class BST(object):
    def __init__(self):
        self.__root = None
    
    @property
    def root(self):
        return self.__root
    
    @root.setter
    def root(self,node):
        if node is None or type(node) is Node:
            self.__root = node
            if type(node) is Node:
                node.parent = None
        else:
            raise Exception,'parent node must be None or Node type' 
    
    def pre_order(self,node):
        #递归结束点
        if node == None:
            return []
        #分支结点
        data = [node.data]
        left = self.pre_order(node.left)
        right = self.pre_order(node.right)
        return data +left +right
    
    def in_order(self,node):
        if node == None:
            return []
        
        left = self.pre_order(node.left)
        data = [node.data]
        right = self.pre_order(node.right)
        return left + data + right
        
    def post_order(self,node):
        if node == None:
            return []
        
        left = self.pre_order(node.left)
        right = self.pre_order(node.right)
        data = [node.data]
        return left + right + data 
    
    #查找以node为根结节的树的最大关键值节点
    def find_max(self,node):
        if node == None:
            return None
        p = node
        while True:
            if p.right != None:
                p = p.right
                continue
            else:
                break
        return p
     
    def  find_min(self,node):
        if node == None:
            return None
        p = node
        while True:
            if p.left != None:
                p = p.left
                continue
            else:
                break
        return p

    def search(self,node,key):
        # 跟二分查找的递归方式非常像
        #结束点
        if node == None:
            return None
        
        #分支节点
        if key == node.data:
            return node
        if key > node.data:
            return self.search(node.right,key)
        else:
            return self.search(node.left,key)

    def insert(self,root,new_node):
        #结束点
        if new_node.data > root.data:
            if root.right == None:
                root.right = new_node
                return True
        if new_node.data == root.data:
            return False
        if new_node.data < root.data:
            if root.left == None:
                root.left = new_node
                return True

        #分支节点
        if new_node.data > root.data:
            if root.right != None:
                branch_ret = self.insert(root.right,new_node)
        if new_node.data < root.data:
            if root.left != None:
                branch_ret = self.insert(root.left,new_node)
        return branch_ret

    def delete(self,node):
        #这个方法比较繁琐，有空再写
        pass