栈，队列，图，二叉树-排序-python

栈

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, item):
        if self.isFull():
            raise StackException('StackOverFlow')
        else:
            self.stack.append(item)
            self.top += 1
    def pop(self):
        if self.isEmpty():
            raise StackException('StackUnderFlow')
        else:
            item = self.stack[-1]
            self.top -= 1
            del self.stack[-1]
            return item
    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

队列

class Queue:
    def __init__(self, size = 20):
        self.queue = []
        self.size = size
        self.end = -1
    def setSize(self, size):
        self.size = size
    def In(self, item):
        if self.end < self.size - 1:
            self.queue.append(item)
            self.end += 1
        else:
            raise QueueException("QueueFull")
    def Out(self):
        if self.end != -1:
            item = self.queue[0]
            self.queue = self.queue[1:]
            self.end -= 1
            return item
        else:
            raise QueueException("QueueEmpty")
    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

图

def main():
    G = ['G', []]
    H = ['H', []]
    I = ['I', []]
    K = ['K', []]
    E = ['E', [G, H, I, K]]
    D = ['D', []]
    F = ['F', []]
    A = ['A', [D , E]]
    B = ['B', []]
    C = ['C', [F]]
    ROOT = ['ROOT', [A, B, C]]
    print(ROOT)

if __name__ == "__main__":
    main()

图的路径探索
路径探索

def searchGraph(graph, start, end):
    results = []
    generatePath(graph, [start], end, results)
    results.sort(key = lambda x:len(x))
    return results

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)

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)

二叉树

class BTree:
    def __init__(self, value):
        self.left = None
        self.value = 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()

二叉树排序

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])
    node = Root
    for i in range(1, len(l)):
        insert(Root, l[i])

inorder(Root)
print("--------------------------")
rinorder(Root)

快速排序

def partition(lyst, low, high):
    pivotkey = lyst[low]
    while low < high:
        while low < high and lyst[high] >= pivotkey:
            high -= 1
        lyst[low] = lyst[high]
        while low < high and lyst[low] <= pivotkey:
            low += 1
        lyst[high] = lyst[low]
    lyst[low] = pivotkey
    return low

def qSort(lyst, low, high):
    if low < high :
        pivotloc =partition(lyst, low, high)
        qSort(lyst, low, pivotloc - 1)
        qSort(lyst, pivotloc + 1, high)

def quickSort(lyst):
    qSort(lyst, 0, len(lyst) - 1)

def main():
    x = [12,23,1,5,123,89,57]
    print(x)
    quickSort(x)
    print(x)

if __name__ == "__main__":
    main()