树形结构：二叉排列树，二叉搜索树

二叉排列树，二叉搜索树

这个数听见得比较多，含义是：左边<=中间<=右边，换句话来说使用中序遍历最后得到结果就是一个有序得序列。

建立一颗二叉排列树

class BinTNode:
    def __init__(self,data=None,left =None,right =None):
        self.data =data
        self.left =left
        self.right =right
                
def buildTree(arr,pointer,N):
    # 递归出口，当越界时就没有必要创建节点了直接return，开始回退
    # 当值为-1时，也没有必要创建结点
    if pointer > N or arr[pointer] == -1:
        return None

    curNode = BinTNode(arr[pointer])

    curNode.left = buildTree(arr,2*pointer+1,N)
    curNode.right = buildTree(arr,2*pointer+2,N)
            
    return curNode
    
def inorder(root):
    if not root:
        return
    else:
        inorder(root.left)
        print(root.data,end=' ')
        inorder(root.right)


arr = [6,2,8,0,4,7,9,-1,-1,3,5]
root = buildTree(arr,0,len(arr)-1)
inorder(root)

runfile('D:/share/test/backtracking/Binary_Search_Tree.py', wdir='D:/share/test/backtracking')
0 2 3 4 5 6 7 8 9 

二叉排列树搜索，他可以天然的使用二叉搜索，通过比较要么在左子树，要么在右子树，要么在当前结点

def inorder(root):
    if not root:
        return
    else:
        inorder(root.left)
        print(root.data,end=' ')
        inorder(root.right)
        
def searchInBinaryTree(root,node_key):
    if not root:
        return False
    if root.data == node_key:
        return True
    elif root.data < node_key:
        return searchInBinaryTree(root.right,node_key)    
    else:
        return searchInBinaryTree(root.left,node_key)

二叉树的共同祖先，二叉树的祖先有4种情况，第一种：全部都在一个子树，第二种：每一颗子树一个，第三种：当前结点就是祖先，第四种：就是没有祖先的情况，由于二叉排列树的性质，可以直接区分这四种情况：

class Solution:
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode data
        :type q: TreeNode data
        :rtype: TreeNode
        """
        if not root or root.data == p or root.data == q:
            return root
        
        if root.data < p and root.data < q:
            return self.lowestCommonAncestor(root.right, p, q)
        
        elif root.data > p and root.data > q:
            return self.lowestCommonAncestor(root.left, p, q)      
        # 一边一个的情况
        else:
            return root 

# 化简修改后如下 ，这里面实际上假设2个结点都存在
class Solution:
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode data
        :type q: TreeNode data
        :rtype: TreeNode
        """       
        if root.data < p and root.data < q:
            return self.lowestCommonAncestor(root.right, p, q)
        
        elif root.data > p and root.data > q:
            return self.lowestCommonAncestor(root.left, p, q)        
        # 实际上这个包含多种请款：
        # not root or root.data == p or root.data == q 和 root.data在p,q之间
        else:
            return root   

    
    # 这里是树形指针的一种用方法，是把递归转化为迭代的一种常用方法
    def lowestCommonAncestorRecursion(self, root, p, q):
        
        pointer = root
        while pointer:
            if pointer.data < p and pointer.data < q:
                pointer = pointer.right
        
            elif pointer.data > p and pointer.data > q:
                pointer = pointer.left        
            else:
                return pointer 

运行结果：

arr = [6,2,8,0,4,7,9,-1,-1,3,5]
root = buildTree(arr,0,len(arr)-1)
inorder(root)
print(searchInBinaryTree(root,9))
t = Solution().lowestCommonAncestorRecursion(root,3,5)
print(t.data if t else t)


runfile('D:/share/test/backtracking/Binary_Search_Tree.py', wdir='D:/share/test/backtracking')
0 2 3 4 5 6 7 8 9 True
4