Pyhton-Leetcode-二叉搜索樹（二叉排序樹、二叉查找樹）

二叉搜索樹是一種所有左子樹小於其父節點，右子樹大於其父節點的特殊二叉樹。

二叉搜索樹主要用來出檢索某個節點。【用於搜索】

二叉搜索樹按照中序遍歷，就能夠得出正確從小到大的序列排序。

面試題54. 二叉搜索樹的第k大節點

考點：二叉搜索樹的性質。首先要知道的就是二叉搜索樹中序遍歷，就是從小到大的序列排序。那麼就可以遍歷一遍，然後輸出k大就行了。BFS+list.sort()  是解法1，很慢。

解法2：遞歸和非遞歸的中序遍歷

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        #########非遞歸##########
        if not root: return 0 
        L = []
        q = []
        node = root
        while(node or q):
            if node:                 ## while(node):q.append(node) node.left 
                q.append(node)
                node= node.left
            else:
                node = q.pop() #最深的那個 
                L.append(node.val) #最左
                node = node.right #轉到右子樹
            if len(L)
        return L[-k]  ##從小到大的 
        
        ############遞歸####################
        if not root :return 0 #
        L = []
        def t(node):
            if node.left:
                t(node.left)
            L.append(node.val)
            if node.right:
                t(node.right)
        t(root)
        return L[-k]

解法3（解法2的優化）

解法2 O(N) O(N) 因爲求解的是K大，右子樹的值肯定要比左子樹大，所以可以按照右-中-左的順序遍歷，當list長度等於K時，立即停止，以節省時間。

遞歸和非遞歸： 來自此處的@JustYou

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:        
        ##非遞歸版本 @JustYou
        if not root :return 0 
        q = []
        count = 0 
        node = root ##不改變原結構
        while(node or q):
            while(node): #直接找到最右的
                q.append(node)
                node = node.right #從右開始 
            if q: #添加最右的信息
                node = q.pop() #最深的那個 
                count +=1
                if count == k : return node.val ##不用保存前k-1個節點,以節省空間
                node = node.left #轉到左子樹
        
        ####遞歸版本##########
        #遞歸版本
        if not root:return 0 #沒有結果返回
        self.count = 0 ##全局
        self.ans = 0  
        def t(node,k):
            if node:
                t(node.right,k)
                self.count += 1 ## 從上到下
                if self.count == k:
                    self.ans = node.val
                    return 
                t(node.left,k)
        t(root,k)
        return self.ans