[从头读历史] 第298节 时间简史 关于黑洞的那些事

剧情提要：

史蒂芬.霍金博士的《时间简史》，主要讲了黑洞，关于黑洞，有什么需要知道的吗？

正剧开始：

星历2016年07月11日 17:02:46, 银河系厄尔斯星球中华帝国江南行省。

[工程师阿伟]正在和[机器小伟]一起研究[时间简史 关于黑洞的那些事]。

彩蛋：(关于栈，队列，二叉树的python实现，只是初步实现)

<span style="font-size:18px;">###
# @usage   数据结构汇总，不断增加中
# @author  mw
# @date    2016年07月11日  星期一  10:06:56
# @param
# @return
#
###

#栈
class Stack:
    def __init__(self, size = 16):
        self.stack = []
        self.size = size
        self.top = -1 

    def setSize(self, size):
        self.size = size 

    def isEmpty(self):
        if self.top == -1:
            return True
        else:
            return False 

    def isFull(self):
        if self.top + 1 == self.size:
            return True
        else:
            return False 

    def top(self):
        if self.isEmpty():
            raise Exception("StackIsEmpty")
        else:
            return self.stack[self.top] 

    def push(self,obj):
        if self.isFull():
            raise Exception("StackOverFlow")
            #self.setSize(self.size*=2);
        else:
            self.stack.append(obj)
            self.top +=1 

    def pop(self):
        if self.isEmpty():
            raise Exception("StackIsEmpty")
        else:
            self.top -= 1
            return self.stack.pop() 

    def show(self):
        print(self.stack) 

    def test(self):
        s = Stack(5)
        s.push(1)
        s.push(2)
        s.push(3)
        s.push(4)
        s.push(5)
        s.show()
        s.pop()
        s.show()
        s.push(6)
        s.show()

#队列
class Queue:
    def __init__(self,size = 16):
        self.queue = []
        self.size = size
        self.front = 0
        self.rear = 0

    def setSize(self, size):
        self.size = size 

    def isEmpty(self):
        return self.rear == 0 

    def isFull(self):
        if (self.front - self.rear +1) == self.size:
            return True
        else:
            return False 

    def first(self):
        if self.isEmpty():
            raise Exception("QueueIsEmpty")
        else:
            return self.queue[self.front] 

    def last(self):
        if self.isEmpty():
            raise Exception("QueueIsEmpty")
        else:
            return self.queue[self.rear] 

    def add(self,obj):
        if self.isFull():
            raise Exception("QueueOverFlow")
        else:
            self.queue.append(obj)
            self.rear += 1 

    def delete(self):
        if self.isEmpty():
            raise Exception("QueueIsEmpty")
        else:
            self.rear -=1
            return self.queue.pop(0)

    def show(self):
        print(self.queue) 

    def test(self):
        q = Queue(3)
        q.add(1)
        q.add(2)
        q.show()
        q.delete()
        q.show()

#二叉树，要用到Queue()
class BinaryTreeNode:
    def __init__(self,data,left,right):
        self.left = left
        self.data = data
        self.right = right 

class BinaryTree:
    def __init__(self):
        self.root = None 

    def makeTree(self,data,left,right):
        self.root = BinaryTreeNode(data,left,right) #left.root = right.root = None 

    def isEmpty(self):
        if self.root is None:
            return True
        else:
            return False 

    def preOrder(self,r):
        if r.root is not None:
            print(r.root.data)
            if r.root.left is not None:
                self.preOrder(r.root.left)
            if r.root.right is not None:
                self.preOrder(r.root.right) 

    def inOrder(self,r):
        if r.root is not None:
            if r.root.left is not None:
                self.inOrder(r.root.left)
            print(r.root.data)
            if r.root.right is not None:
                self.inOrder(r.root.right)

    def postOrder(self,r):
        if r.root is not None:
            if r.root.left is not None:
                self.preOrder(r.root.left)
            if r.root.right is not None:
                self.preOrder(r.root.right)
                print(r.root.data) 

    def levelOrder(self,a):
        q = Queue()
        r = a
        while r is not None:
            print(r.root.data)
            if r.root.left is not None:
                q.add(r.root.left)
            if r.root.right is not None:
                q.add(r.root.right) 

            if q.isEmpty():
                print("empty")
                r = None
            else:
                r = q.delete() 

    def test(self):
        r = BinaryTree()
        ra = BinaryTree()
        ra.makeTree(2,None,None)
        rb = BinaryTree()
        rb.makeTree(3,None,None)
        r.makeTree(1,ra,rb)
        print("前序遍历")
        r.preOrder(r)
        print("中序遍历")
        r.inOrder(r)
        print("后序遍历")
        r.postOrder(r)
        print("层级遍历")
        r.levelOrder(r)

    def findTree(self, preList,inList,postList):
        if len(preList)==0:
            return
        if len(preList)==1:
            postList.append(preList[0])
            return
        root=preList[0]
        n = inList.index(root)
        self.findTree(preList[1:n+1],inList[:n],postList)
        self.findTree(preList[n+1:],inList[n+1:],postList)
        postList.append(root)

    #已知前序遍历结果和中序遍历结果，求后序遍历
    def test2(self):
        preList=list('DBACEGF')
        midList=list('ABCDEFG')
        afterList=[]

        self.findTree(preList,midList,afterList)
        print(afterList)

if __name__ == '__main__':
    stack = Stack();
    stack.test();

    queue = Queue();
    queue.test();

    btree = BinaryTree();
    btree.test();

    btree.test2();</span>

本节到此结束，欲知后事如何，请看下回分解。