二叉搜索树BST和AVL总结

Binary Sorted Tree
BST树的插入，删除， 查找都是logn。

插入

class TreeNode:
	def __init__(self, val):
		self.val = val
		self.left = None
		self.right = None

def insert_BST(root, k):
	if not root:
		root = TreeNode(k)
		return 
	else:
		#if root.val == k:
		#	return 
		if root.val >= k: # 无论怎么样都可以找到一个合适的位置进行插入的。直到root=None。
			insert_BST(root.left, k)
		else:
			insert_BST(root.right, k)

二叉搜索树的查找和折半查找差不多~~logn

def search(root, k, pre):
	if not root or root.val == k:
		return root
	if root.val > k:
		res = search(root.right, k, root)
	else:
		res = search(root.left, k, root)
	return res, pre

删除：
分为三种：没有左子树，没有右子树，有左子树和右子树
删除关键字为k的节点。

def search_max(root, pre):
	if not root.right:
		return root, pre
	else:
		search_max(root.right, root)
		
def detete_root(root, k):
	de_root, pre = search(root, k)
	if not de_root:
		return
		 
	if not de_root.left and not de_root.right:
		if pre.left == root:
			pre.left = None
		else:
			pre.right = None
		return 
		
	elif not de_root.left：
		if de_root == pre.left:
			pre.left = de_root.right  ###
		else:
			pre.right = de_root.right
		
	elif not de_root.right:
		res, pre = search_max(de_root.left)
		delete_root(pre, res.val)
		if de_root == pre.left:
			pre.left = res
			res.left = de_root.left
		else:
			pre.right = res
			res.left = de_root.left

给定一棵二叉搜索树，找出第k大的节点。

这道题的麻烦之处在于第k大，要清楚，如果是1，则是最后一个结点。那么如果是中序遍历，肯定要从第一个结点到最后一个结点都遍历一下，可能还要存储来得到倒数第k个。

改进一下中序遍历，原本是左中右，现在改成右中左。就可以从最右边开始遍历。直接求第k个即可，不需要存储之类的。

class Solution(object):  # 中序遍历的改进版！
    def __init__(self):
        self.count = 0
        self.val = 0

    def kthLargest(self, root, k):
        def dfs(root):
            if not root:
                return
            self.kthLargest(root.right, k)
            if self.count == k:
                return
            self.count += 1

            if self.count == k:
                self.val = root.val
                return
            self.kthLargest(root.left, k)

        dfs(root)
        return self.val