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 node.data == key:
return node

#分支节点
if key > node.data:
branch_ret = self.search(node.right,key)
else:
branch_ret = self.search(node.left,key)
return branch_ret

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