二叉树搜索树：概念、特性与应用-CSDN博客

本文链接：https://blog.csdn.net/2301_77623084/article/details/147354202

什么是完全二叉树？

二叉搜索树（Binary Search Tree，简称BST）是计算机科学中最基础且实用的数据结构之一。本文将全面介绍BST的概念、特性、实现方法以及实际应用，帮助读者深入理解这一重要数据结构

什么是完全二叉树？

完全二叉树是一种特殊的二叉树结构，它满足以下两个条件：

除了最后一层外，所有层都完全填满
最后一层的所有节点都尽可能地向左靠拢

换句话说，完全二叉树从根节点到倒数第二层形成一个完美二叉树（所有非叶子节点都有两个子节点），而最后一层的节点都连续集中在左侧。

完全二叉树示例

以下是一个完全二叉树的例子：

而下面这些都不是完全二叉树：

        A           A
      /   \       /   \
     B     C     B     C
    / \     \   / \   / \
   D   E     G D   E F   G
              /
             H

完全二叉树的特性

高度计算：具有n个节点的完全二叉树，其高度为⌊log₂n⌋
数组表示：完全二叉树可以高效地用数组表示，不需要指针：
- 对于索引i的节点：
  - 父节点：(i-1)/2
  - 左子节点：2i+1
  - 右子节点：2i+2
插入顺序：新节点总是从最低层最左边的可用位置插入

什么是二叉搜索树？

二叉搜索树是一种特殊的二叉树数据结构，它具有以下关键性质：

有序性：对于树中的每个节点：
- 左子树所有节点的值都小于该节点的值
- 右子树所有节点的值都大于该节点的值
递归结构：每个子树也都是二叉搜索树
动态结构：可以高效地进行插入、删除和查找操作

完全二叉树与二叉搜索树的区别

二叉搜索树(BST)，它与完全二叉树有以下区别：

特性	二叉搜索树(BST)	完全二叉树
节点顺序	左子树所有节点值 < 根节点值 < 右子树所有节点值	没有特定顺序要求
结构要求	无特殊结构要求	必须满足完全填充和左对齐条件
主要用途	快速查找、插入、删除	高效存储、堆实现
示例	代码中构建的树	二叉堆使用的结构

二叉搜索树的基本操作

1. 节点结构定义

typedef struct Node {
    int data;           // 节点存储的数据
    struct Node *left;  // 左子节点指针
    struct Node *right; // 右子节点指针
} Node;

这个简洁的结构体定义了BST的基本组成单元，包含数据存储和左右子节点连接

2. 插入操作

Node *insert(Node *root, int val) {
    if (root == NULL) {
        root = (Node *)malloc(sizeof(Node));
        root->data = val;
        root->left = root->right = NULL;
        return root;
    }
    if (val < root->data) {
        root->left = insert(root->left, val);
    } else {
        root->right = insert(root->right, val);
    }
    return root;
}

插入过程分析：

从根节点开始递归查找合适位置
遇到空位置时创建新节点
始终保持BST的有序性质
平均时间复杂度：O(log n)

3. 查找操作

Node *search(Node *root, int val) {
    if (root == NULL || root->data == val) {
        return root;
    }
    if (val < root->data) {
        return search(root->left, val);
    }
    return search(root->right, val);
}

查找特点：

利用BST的有序性进行高效查找
类似二分查找，每次比较可排除一半子树
平均时间复杂度：O(log n)

4. 删除操作（最复杂）

以下是完整的删除操作代码：

// 找到子树中的最小节点（辅助删除操作）
Node *findMin(Node *node)
{
    while (node->left != NULL)
    {
        node = node->left;
    }
    return node;
}

// 删除节点
Node *delete(Node *root, int val)
{
    if (root == NULL)
        return root;

    // 1.找到要删除的节点
    if (val < root->data)
    {
        root->left = delete (root->left, val);
    }
    else if (val > root->data)
    {
        root->right = delete (root->right, val);
    }
    else
    {
        // 2.找到删除的节点后，根据子节点情况进行处理

        // 情况1：节点是叶子节点或只有一个子节点
        if (root->left == NULL)
        {
            Node *temp = root->right;
            free(root);
            return temp;
        }
        else if (root->right == NULL)
        {
            Node *temp = root->left;
            free(root);
            return temp;
        }

        // 情况2：节点有两个子节点
        // 找到该节点右子树的最小节点
        Node *temp = findMin(root->right);

        // 用最小节点的值替换当前节点
        root->data = temp->data;

        // 删除原节点右子树的最小节点
        root->right = delete (root->right, temp->data);
    }
    return root;
}

第一步：查找要删除的节点

if (val < root->data) {
    root->left = delete(root->left, val);
} else if (val > root->data) {
    root->right = delete(root->right, val);
} else {
    // 找到要删除的节点
}

这部分代码通过递归在BST中查找要删除的节点。BST的性质保证了我们可以高效地定位目标节点。

第二步：处理找到的节点

找到要删除的节点后，根据其子节点数量分为三种情况处理：

情况1：节点是叶子节点（无子节点）

if (root->left == NULL && root->right == NULL) {
    free(root);
    return NULL;
}

这是最简单的情况，直接释放节点内存并返回NULL给父节点。

情况2：节点有一个子节点

if (root->left == NULL) {
    Node* temp = root->right;
    free(root);
    return temp;
} else if (root->right == NULL) {
    Node* temp = root->left;
    free(root);
    return temp;
}

处理方式：

如果只有右子节点，用右子节点替代当前节点
如果只有左子节点，用左子节点替代当前节点
释放原节点内存

情况3：节点有两个子节点

// 找到该节点右子树的最小节点
        Node *temp = findMin(root->right);

        // 用最小节点的值替换当前节点
        root->data = temp->data;

        // 删除原节点右子树的最小节点
        root->right = delete (root->right, temp->data);

处理方式：

找到右子树中的最小值节点（或左子树中的最大值节点）
用这个最小节点的值替换当前要删除的节点的值
递归删除那个最小节点

这种方法保证了BST的性质不被破坏，因为右子树的最小值一定大于左子树的所有值，小于右子树的其他值

示例分析

假设我们有如下BST：

        50
       /  \
     30    70
    / \   / \
  20 40 60 80

示例1：删除叶子节点(20)

步骤：

找到节点20
发现它是叶子节点
直接删除，返回NULL给父节点30的左指针

结果：

示例2：删除有一个子节点的节点(30)

步骤：

找到节点30
发现它只有右子节点40
用40替代30的位置

结果：

示例3：删除有两个子节点的节点(50)

步骤：

找到节点50
找到右子树的最小节点60
用60替换50的值
递归删除原来的60节点

结果：

(注意：这里的"-"表示NULL)

二叉搜索树的遍历方式

BST支持三种经典遍历方式，各有特点和应用场景：

1. 前序遍历（根-左-右）

void preorder(Node *root) {
    if (root == NULL) return;
    printf("%d ", root->data);
    preorder(root->left);
    preorder(root->right);
}

应用：复制树结构、前缀表达式