이진 트리의 재귀 비 재귀 순회를 만들기

이진 트리이 이진 트리의 기본적인 기술 중 하나입니다, 정상적인 작동을 통과한다

클래스 TreeNode를 () :
     DEF  __init__ (자체, X) : 
        self.val = X 
        self.left = 없음 
        self.right = 없음 

클래스 BinaryTree (객체) :
     DEF  __init__ (자체는, 사전, 주석) : 
        self.pre = 미리 
        자기 .tin = 
        self.levelTrave = [] # 계층 탐색 결과 
        self.preTraveRecur = [] # 프리앰블 재귀 탐색 결과 
        self.preTraveNoRecur = [] #의 프리앰블 비 재귀 탐색 결과 
        self.inTraveRecur = [] #을순서로 순환 탐색 결과에서 
        self.inTraveNoRecur = [] # 차 비 재귀 탐색 결과는 
        self.postTraveRecur = [] # postorder 재귀 탐색 결과 
        self.postTraveNoRecur = [] #에 postorder 비 재귀 탐색 결과 

    # 선주문 순회 사용 전과 결과는 이진 트리 탐색 순서 재구성 
    DEF : reConstructBinaryTree는 (자체가, 미리, 주석) #의 전순 순회 주석 전순 결과 예비 결과를 
        IF (프리) == 렌 0
             복귀 없음
         IF . 렌 (프리) == 1 :
             반환 TreeNode를가 ([0] 사전)
         다른 : 
            RES = TreeNode를 (프리 [0]) 
            res.left을Self.reConstructBinaryTree = (이전 [1. tin.index (프리 [0]) + 1. :], 주석이 [tin.index은 ([0]) 중고]) 
            res.right (= self.reConstructBinaryTree (프리 [tin.index을 예비 [0]) + 1.] 주석 [tin.index는 (프리 [0]) + 1. :)]
         복귀 RES의 

    #은 레벨 통과 
    DEF levelTraversal (자기, PROOT 일) : 
        AUX가 = []
         IF PROOT = 없음! # 비 빈 루트 노드의 목록에 추가 AUX 
            AUX = [PROOT] 

        그동안 렌 (AUX) : #이 소자 방문 계속하거나 끝 통과 할있을 경우, AUX리스트 요소가 있는지 여부를 결정 
            (0) p = aux.pop을 # 마다 큐 시뮬레이션리스트의 첫 번째 요소 취할 
            self.levelTrave.append (p.val)를
            IF p.left = 없음 :! # 현재 요소 목록의 AUX 단부 가입 제 노드를 떠난 경우 
                aux.append (p.left)
             IF p.right = 없음 :! #가 현재 노드의 첫번째 요소는 AUX 합류하는 권리가있는 경우를 목록의 끝 
                aux.append (p.right) 

    #의 예약 주문 재귀 탐색 
    DEF : preorderTraversalRecursion (자체, PROOT)
         IF PROOT == 없음 :
             리턴 
        self.preTraveRecur.append (pRoot.val) # ! ! ! ! ! ! ! 
        IF pRoot.left! = 없음 : 
            self.preorderTraversalRecursion (pRoot.left) 
        IF pRoot.right! = 없음 : 
            self.preorderTraversalRecursion (pRoot.right)

    # 프리앰블 비 재귀 순회 
    DEF preorderTraversalNoRecursion (자기, PROOT)
         IF PROOT == 없음 :
             리턴 
        는 AUX = [] 
        노드 = PROOT을
         그동안 노드 또는 AUX는 :
             그동안 노드 :
                 # 1 루트부터의 좌측 서브 트리를 찾고있다 
                자체 .preTraveNoRecur.append (node.val) 
                aux.append (노드) 
                노드 = node.left
                 # 끝 노드가 현재 노드가 트리 노드의 더 왼쪽 아이가없는 전에 해당 비어 있음을 나타냅니다 동안 
            노드 = aux.pop을 ()
             #그것은 바로 하위 트리보고 시작 
            노드 = node.right 

    #을 위해 재귀 탐색 
    DEF inorderTraversalRecursion (자체, PROOT) :
         IF PROOT == 없음 :
             리턴 
        IF ! PRoot.left = : 없음 
            self.inorderTraversalRecursion (pRoot.left) 
        자체. inTraveRecur.append (pRoot.val) # ! ! ! ! ! ! ! ! 
        IF pRoot.right! = 없음 : 
            self.inorderTraversalRecursion (pRoot.right) 

    # 주문 비 재귀 주사로 
    DEF inorderTraversalNoRecursion (자체, PROOT) :
         IF 루트 == : 없음
             반환
        는 AUX = [] 
        노드 = 루트
         그동안 노드 또는 AUX :
             그동안 노드 :
                 #이   루트에서 시작하여 좌측 서브 트리에서 발견되었다 
                aux.append (노드) 
                노드 = node.left
             # 엔드 노드는 현재 노드가 비어 있음을 나타내는 반면하는 전 노드에는 좌측 서브 트리가없는 
            노드 = aux.pop () 
            self.inTraveNoRecur.append (node.val) 
            노드 = node.right 

    # postorder 순회 재귀 
    DEF postorderTraversalRecursion (자기, PROOT)
         IF PROOT ==없음 :
             반환 
        하는 경우 ! pRoot.left = 없음 : 
            self.postorderTraversalRecursion (pRoot.left) 
        의 경우 pRoot.right! = 없음 : 
            self.postorderTraversalRecursion (pRoot.right) 
        self.postTraveRecur.append (pRoot.val) # !!!! ! 

    # 后序非递归遍历
    DEF postorderTraversalNoRecursion (자기, pRoot)
         만약 루트 == 없음 :
             
        AUX = [] 
        노드 = 루트
         동안 노드 또는 AUX :
             반면노드 :
                 # 루트에서 시작은, 오른쪽 서브 트리를 찾고있다 
                self.postTraveNoRecur.insert (0, node.val) 
                aux.append (노드) 
                노드 = node.right
             # 끝 노드는 현재 노드가 비어 있음을 나타냅니다 동안 그 전에 우측 자식 노드가되지 
            노드 = ) (aux.pop
             #는 그 좌측 서브 트리를 찾기 시작 
            = 노드 node.left 

IF  __name__ == ' __main__ ' :
     # 프리앰블 및 재구성 된 이진 선주문하여 
    미리 = [1, 2 ,. 4 ,. 7 ,. 3 ,. 5 ,. 6 ,. 8 ] 
    의 TiN =. 4 ,. 7,2 ,. 1 ,. 5 ,. 3 ,. 8 ,. 6 ] 
    BT =BinaryTree (사전, 주석) 
    루트 = BT.reConstructBinaryTree (BT.pre, BT.tin) 

    # 트래버스 수준 
    BT.levelTraversal (루트)
     인쇄 ( " 결과를 통해 수준 : " , BT.levelTrave) 

    #의 순서 재귀 탐색 
    BT.preorderTraversalRecursion (루트)
     인쇄 ( " 사전 주문 재귀 탐색 : " , BT.preTraveRecur) 

    #의 선주문 비 재귀 탐색 
    BT.preorderTraversalNoRecursion (루트)
     인쇄 ( " 프리앰블 비 재귀 탐색 : " , BT.preTraveNoRecur) 

    # 재귀 탐색 순서 
    BT .inorderTraversalRecursion (루트)
     인쇄 ( "위해 재귀 탐색에서 : " , BT.inTraveRecur) 

    # 주문 비 재귀 주사로 
    BT.inorderTraversalNoRecursion (루트)
     인쇄 ( " 비 재귀 탐색 순서 " , BT.inTraveNoRecur) 

    # postorder 재귀 탐색 
    BT.postorderTraversalRecursion (루트)
     인쇄 ( " postorder 순회 재귀 " , BT.postTraveRecur) 

    #의 주문 후 비 - 재귀 탐색 
    BT.postorderTraversalNoRecursion (루트)
     인쇄 ( " postorder 통과 비 재귀 " , BT.postTraveNoRecur)

 

추천

출처www.cnblogs.com/shnuxiaoan/p/12241694.html