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

标签：

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

彩蛋：(关于栈，队列，二叉树的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>

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

标签：

原文地址：http://blog.csdn.net/mwsister/article/details/51882540