m0_69131688 2022-06-12 10:20 采纳率: 100%
浏览 74
已结题

求每种算法时空复杂度

求下列代码的每种算法的时间和空间复杂度
from collections import deque

class BTNode:                                        #构建二叉树
    def __init__(self,d=None):                        
        self.data=d                                   
        self.lchild=None                            
        self.rchild=None                           
class BTree:                                       
    def __init__(self,d=None):                        
        self.b=None                               
    def SetRoot(self,r):                           
        self.b=r
    def DispBTree(self):                            
        return self._DispBTree1(self.b)
    def _DispBTree1(self,t):                       
        if t==None:                                 
            return ""
        else:
            bstr=t.data                                
            if t.lchild!=None or t.rchild!=None:
                bstr+="("                            
                bstr+=self._DispBTree1(t.lchild)    
                if t.rchild!=None:
                    bstr+=","                        
                bstr+=self._DispBTree1(t.rchild)    
                bstr+=")"                            
            return bstr

    def FindNode(self,x):                            #查找值为x的结点算法
        return self._FindNode1(b,x)
    def _FindNode1(self,t,x):                       
        if t==None: 
            return None                                
        elif t.data==x: 
            return t                                
        else:
            p=self._FindNode1(t.lchild,x)            
            if p!=None: 
                return p                            
            else:
                return self._FindNode1(t.rchild,x)    

   def Height(self):                                #求二叉树高度的算法
        return self._Height1(b)
    def _Height1(self,t):                           
        if t==None:
            return 0                                
        else:
            lh=self._Height1(t.lchild)                
            rh=self._Height1(t.rchild)                
            return max(lh,rh)+1

def PreOrder(bt):                                    #先序遍历
    PreOrder1(bt.b)
def PreOrder1(t):                                   
    if t!=None:
        print(t.data,end=' ')                        
        PreOrder1(t.lchild)                           
        PreOrder1(t.rchild)                           
def InOrder(bt):                                       #中序遍历
    InOrder1(bt.b)
def InOrder1(t):                                     
    if t!=None:
        InOrder1(t.lchild)                           
        print(t.data,end=' ')                       
        InOrder1(t.rchild)                           
def PostOrder(bt):                                   #后序遍历
    PostOrder1(bt.b)
def PostOrder1(t):                                  
    if t!=None:
        PostOrder1(t.lchild)                       
        PostOrder1(t.rchild)                        
        print(t.data,end=' ')                       
def LevelOrder(bt):                                 #层次遍历
    qu=deque()                                      
    qu.append(bt.b)                                   
    while len(qu)>0:                              
        p=qu.popleft()                              
        print(p.data,end=' ')                      
        if p.lchild!=None:                           
            qu.append(p.lchild)
        if p.rchild!=None:                            
            qu.append(p.rchild)from collections import deque

class BTNode:                                        #构建二叉树
    def __init__(self,d=None):                        
        self.data=d                                   
        self.lchild=None                            
        self.rchild=None                           
class BTree:                                       
    def __init__(self,d=None):                        
        self.b=None                               
    def SetRoot(self,r):                           
        self.b=r
    def DispBTree(self):                            
        return self._DispBTree1(self.b)
    def _DispBTree1(self,t):                       
        if t==None:                                 
            return ""
        else:
            bstr=t.data                                
            if t.lchild!=None or t.rchild!=None:
                bstr+="("                            
                bstr+=self._DispBTree1(t.lchild)    
                if t.rchild!=None:
                    bstr+=","                        
                bstr+=self._DispBTree1(t.rchild)    
                bstr+=")"                            
            return bstr

    def FindNode(self,x):                            #查找值为x的结点算法
        return self._FindNode1(b,x)
    def _FindNode1(self,t,x):                       
        if t==None: 
            return None                                
        elif t.data==x: 
            return t                                
        else:
            p=self._FindNode1(t.lchild,x)            
            if p!=None: 
                return p                            
            else:
                return self._FindNode1(t.rchild,x)    

   def Height(self):                                #求二叉树高度的算法
        return self._Height1(b)
    def _Height1(self,t):                           
        if t==None:
            return 0                                
        else:
            lh=self._Height1(t.lchild)                
            rh=self._Height1(t.rchild)                
            return max(lh,rh)+1

def PreOrder(bt):                                    #先序遍历
    PreOrder1(bt.b)
def PreOrder1(t):                                   
    if t!=None:
        print(t.data,end=' ')                        
        PreOrder1(t.lchild)                           
        PreOrder1(t.rchild)                           
def InOrder(bt):                                       #中序遍历
    InOrder1(bt.b)
def InOrder1(t):                                     
    if t!=None:
        InOrder1(t.lchild)                           
        print(t.data,end=' ')                       
        InOrder1(t.rchild)                           
def PostOrder(bt):                                   #后序遍历
    PostOrder1(bt.b)
def PostOrder1(t):                                  
    if t!=None:
        PostOrder1(t.lchild)                       
        PostOrder1(t.rchild)                        
        print(t.data,end=' ')                       
def LevelOrder(bt):                                 #层次遍历
    qu=deque()                                      
    qu.append(bt.b)                                   
    while len(qu)>0:                              
        p=qu.popleft()                              
        print(p.data,end=' ')                      
        if p.lchild!=None:                           
            qu.append(p.lchild)
        if p.rchild!=None:                            
            qu.append(p.rchild)
  • 写回答

2条回答 默认 最新

  • Hann Yang 全栈领域优质创作者 2022-06-12 21:01
    关注

    二叉树只遍历一次的运算都是: 时间复杂度O(n)空间复杂度O(n)

    还有以下规律,但这些代码没涉及:
    插入节点、搜索节点还是删除节点的时间复杂度O(logn),排序的时间复杂度O(nlogn)

    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
查看更多回答(1条)

报告相同问题?

问题事件

  • 系统已结题 6月25日
  • 已采纳回答 6月17日
  • 创建了问题 6月12日

悬赏问题

  • ¥50 adb连接不到手机是怎么回事?
  • ¥15 vs2022无法联网
  • ¥15 TCP的客户端和服务器的互联
  • ¥15 VB.NET操作免驱摄像头
  • ¥15 笔记本上移动热点开关状态查询
  • ¥85 类鸟群Boids——仿真鸟群避障的相关问题
  • ¥15 CFEDEM自带算例错误,如何解决?
  • ¥15 有没有会使用flac3d软件的家人
  • ¥20 360摄像头无法解绑使用,请教解绑当前账号绑定问题,
  • ¥15 docker实践项目