二叉树与二叉搜索树

1. 什么是二叉树？

二叉树是一种树形结构，它的每个节点最多只有两个子节点。这两个子节点分别称为左子节点和右子节点。二叉树具有以下特点：

• 每个节点最多只有两个子节点
• 左子树和右子树是有顺序的，不能互换
• 二叉树下层的节点只能连接在上一层节点的左子节点或右子节点上。

2. 什么是二叉搜索树？

二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树。它具有以下特点：

• 每个节点的值都大于其左子树中任意一个节点的值
• 每个节点的值都小于其右子树中任意一个节点的值
• 左右子树都是二叉搜索树

2.1 二叉搜索树图示

下面是一个简单的二叉搜索树的图示

         8
       /   \
      3     10
     / \      \
    1   6      14
       / \     / \
      4   7  13   15

3. 二叉树和二叉搜索树常见操作

3.1 二叉树常见操作

3.1.1 二叉树遍历

二叉树遍历是指按照某种顺序遍历二叉树的所有节点。二叉树遍历可以分为三种方式：

• 前序遍历： 先访问根节点，再访问左子树，最后访问右子树。
• 中序遍历： 先访问左子树，再访问根节点，最后访问右子树。
• 后序遍历： 先访问左子树，再访问右子树，最后访问根节点。

在代码中实现二叉树遍历可以使用递归或迭代的方式。下面是一个二叉树的前序遍历的递归实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def preorderTraversal(root: TreeNode) -> List[int]:
    res = []
    def dfs(node):
        if not node:
            return
        res.append(node.val)
        dfs(node.left)
        dfs(node.right)
    dfs(root)
    return res

3.1.2 二叉树的层次遍历

二叉树的层次遍历是指按照每一层从左到右的顺序遍历所有节点。在代码中实现二叉树的层次遍历可以使用BFS（广度优先搜索）的方式。下面是一个二叉树的层次遍历的实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def levelOrder(root: TreeNode) -> List[List[int]]:
    res = []
    queue = []
    if root:
        queue.append(root)
    while queue:
        size = len(queue)
        level = []
        for i in range(size):
            node = queue.pop(0)
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        res.append(level)
    return res

3.1.3 二叉树的搜索

二叉树的搜索是指在二叉树中查找某个特定的值。在二叉树中搜索一个值时，可以使用递归或迭代的方式进行搜索。下面是一个二叉树中查找某个值的递归实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def searchBST(root: TreeNode, val: int) -> TreeNode:
    if not root or root.val == val:
        return root
    if root.val > val:
        return searchBST(root.left, val)
    else:
        return searchBST(root.right, val)

3.2 二叉搜索树常见操作

3.2.1 二叉搜索树的插入

当往一个二叉搜索树中插入一个新节点时，需要先找到新节点在二叉搜索树中的位置，然后将其插入到正确的位置。下面是一个二叉搜索树的插入的实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
    
def insertIntoBST(root: TreeNode, val: int) -> TreeNode:
    if not root:
        return TreeNode(val)
    if root.val > val:
        root.left = insertIntoBST(root.left, val)
    else:
        root.right = insertIntoBST(root.right, val)
    return root

3.2.2 二叉搜索树的删除

当从一个二叉搜索树中删除一个节点时，需要考虑该节点的左右子节点，以及它的父节点。下面是一个二叉搜索树的删除的实现：

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

def deleteNode(root: TreeNode, key: int) -> TreeNode:
    if not root:
        return None
    if root.val > key:
        root.left = deleteNode(root.left, key)
    elif root.val < key:
        root.right = deleteNode(root.right, key)
    else:
        if not root.left and not root.right:
            root = None
        elif root.right:
            root.val = successor(root)
            root.right = deleteNode(root.right, root.val)
        else:
            root.val = predecessor(root)
            root.left = deleteNode(root.left, root.val)
    return root

def successor(node):
    node = node.right
    while node.left:
        node = node.left
    return node.val
    
def predecessor(node):
    node = node.left
    while node.right:
        node = node.right
    return node.val

4. 总结

二叉树是一种常见的树形结构，而二叉搜索树则是一种特殊的二叉树。二叉树和二叉搜索树的遍历、插入、删除等操作是算法和数据结构中的基本问题，同时也是计算机科学方向的重要研究内容。熟练掌握二叉树和二叉搜索树的相关操作，在编写程序时可以帮助我们更高效地解决问题。