Python宝典第五章：数据结构与算法

表：列表来创建

栈：

<span style="font-size:14px;"># -*- coding:utf-8 -*-
# file: pystack.py
#
class PyStack:
    def __init__(self, size = 20):
        self.stack=[]
        self.size=size
        self.top=-1
    def setSize(self, size):
        self.size=size
    def push(self, element):
        if self.isFull():
            raise StackException("PyStackOverFlow")
        else:
            self.stack.append(element)
            self.top=self.top+1
    def pop(self):
        if self.isEmpty():
            raise StackException("PyStackUnderFlow")
        else:
            element = self.stack[-1]
            self.top=self.top-1
            del self.stack[-1]
            return element
    def Top(self):
        return self.top
    def empty(self):
        self.stack=[]
        self.top=-1
    def isEmpty(self):
        if self.top==-1:
            return True
        else:
            return False
    def isFull(self):
        if self.top==self.size-1:
            return True
        else:
            return False

class StackException(Exception):
    def __init__(self,data):
        self.data=data
    def __str__(self):
        return self.data

if __name__=="__main__":
    stack=PyStack()
    for i in range(10):
        stack.push(i)
    print(stack.Top())
    for i in range(10):
        print(stack.pop())
    stack.empty()</span>

队列：

# -*- coding:utf-8 -*-
# file: pyqueue.py
#
class PyQueue:
    def __init__(self,size=20):
        self.queue=[]
        self.size=size
        self.end=-1
    def setSize(self, size):
        self.size=size
    def In(self, element):
        if self.end<self.size-1:
            self.queue.append(element)
            self.end=self.end+1
        else:
            raise QueueException("PyQueueFull")
    def Out(self):
        if self.end !=-1:
            element=self.queue[0]
            self.queue=self.queue[1:]
            self.end=self.end-1
            return element
        else:
            raise QueueException("PyQueueEmpty")
    def End(self):
        return self.end
    def empty(self):
        self.queue=[]
        self.end=-1

class QueueException(Exception):
    def __init__(self,data):
        self.data=data
    def __str__(self):
        return self. data

if __name__=="__main__":
    queue=PyQueue()
    for i in range(10):
        queue.In(i)
        #print(i)
    print(queue.End())
    for i in range(10):
        #queue.Out();
        print(queue.Out())
    for i in range(20):
        queue.In(i)
    queue.empty()

二叉树：

# -*- coding:utf-8 -*-
# file: pybtree.py
#
class BTree:
    def __init__(self, value):
        self.left=None
        self.data=value
        self.right=None
    def insertLeft(self, value):
        self.left=BTree(value)
        return self.left
    def insertRight(self, value):
        self.right=BTree(value)
        return self.right
    def show(self):
        print(self.data)
def preorder(node):
    if node.data:
        node.show()
        if node.left:
            preorder(node.left)
        if node.right:
            preorder(node.right)
def inorder(node):
    if node.data:        
        if node.left:
            inorder(node.left)
        node.show()
        if node.right:
            inorder(node.right)
def postorder(node):
    if node.data:        
        if node.left:
            postorder(node.left)
        if node.right:
            postorder(node.right)
        node.show()
if __name__=="__main__":
    Root=BTree("Root")
    A=Root.insertLeft("A")
    C=A.insertLeft("C")
    D=A.insertRight("D")
    F=D.insertLeft("F")
    G=D.insertRight("G")
    B=Root.insertRight("B")
    E=B.insertRight("E")
    print("***********************")
    preorder(Root)
    print("***********************")
    inorder(Root)
    print("***********************")
    postorder(Root)

图：用字典表示，每个元素是字典的键，元素指向的其他元素是值

# -*- coding:utf-8 -*-
# file: pygraph.py
#
def generatePath(graph, path, end, results):
    state=path[-1]
    if state==end:
        results.append(path)
    else:
        for arc in graph[state]:
            if arc not in path:
                generatePath(graph, path+[arc], end, results)
def searchGraph(graph, start, end):
    results=[]
    generatePath(graph, [start], end, results)
    results.sort(key=lambda x:len(x))
    return results
if __name__=="__main__":
    Graph={ "A": ["B", "C" , "D"],
            "B": ["E"],
            "C": ["D", "F"],
            "D": ["B", "E", "G"],
            "E": [],
            "F": ["D", "G"],
            "G": ["E"]}
    r=searchGraph(Graph, "A", "D")
    for i in r:
        print(i)

二分查找：必须已经排序好

# -*- coding:utf-8 -*-
# file: pyBinarySearh.py
#
def BinarySearch(l, key):
    low=0
    high=len(l)-1
    i=0
    while(low<=high):
        i=i+1
        mid=(low+high)//2
        if (l[mid]>key):
            high=mid-1
        elif (l[mid]<key):
            low=mid+1
        else:
            print("use %d time(s)" % i)
            return mid
    return -1
if __name__=="__main__":
    l=[1,5,6,9,10,51,62,65,70]
    print(BinarySearch(l,65))

二叉树排序：中序遍历是从小到大，从大到小则先从右子树开始进行中序遍历

# -*- coding:utf-8 -*-
# file: pySort.py
#
class BTree:
    def __init__(self, value):
        self.left=None
        self.data=value
        self.right=None
    def insertLeft(self, value):
        self.left=BTree(value)
        return self.left
    def insertRight(self, value):
        self.right=BTree(value)
        return self.right
    def show(self):
        print(self.data)
def inorder(node):
    if node.data:        
        if node.left:
            inorder(node.left)
        node.show()
        if node.right:
            inorder(node.right)
def rinorder(node):
    if node.data:        
        if node.right:
            rinorder(node.right)
        node.show()
        if node.left:
            rinorder(node.left)
def insert(node, value):
    if value > node.data:
        if node.right:
            insert(node.right, value)
        else:
            node.insertRight(value)
    else:
        if node.left:
            insert(node.left, value)
        else:
            node.insertLeft(value)
if __name__=="__main__":
    l=[3,5,7,20,43,2,15,30]
    Root=BTree(l[0])
    for i in range(1, len(l)):
        insert(Root, l[i])
    inorder(Root)
    print("**********************")
    rinorder(Root)