二叉搜索树-BST-查找算法-插入算法-删除算法

最新推荐文章于 2019-08-11 14:17:43 发布

weixin_34321977

最新推荐文章于 2019-08-11 14:17:43 发布

阅读量151

点赞数

本文详细介绍了二叉搜索树的基本概念及其核心算法，包括查找、插入及删除操作的具体实现过程。通过对这些算法的深入探讨，有助于读者理解二叉搜索树的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 简述

最近打算复习一下，几个经典的树结构，本文主要关注二叉搜索树，英文名称为Binary Search Tree (简称BST)。
本文主要总结二叉搜索树的查找算法、插入算法和删除算法。

2. 查找算法

这个比较简单，要么找到了，要么向左，要么向右。

BSTNode * bst_search(BSTNode * node, int value) {
   while (node != NULL) {
     if (value < node -> value) // 向左
      node = node -> left;
     else if (value > node -> value) // 向右
      node = node -> right;
     else // 找到
       return node;
  }
   return NULL; // 失败
}

3. 插入算法

这个也不难，首先找到插入的位置，要么向左，要么向右，直到找到空结点，即为插入位置，如果找到了相同值的结点，插入失败。

bool bst_insert(BSTNode *& root, int value) {
BSTNode* pre = NULL;

BSTNode* curr = root;
   while (curr != NULL) {
     if (value < curr -> value) { // 向左
      pre = curr;
      curr = curr -> left;

    }
     else if (value > curr -> value) { // 向右
      pre = curr;
      curr = curr -> right;

    }
     else // 失败
       return false ;
  }
  curr = new BSTNode; // 插入
  curr -> value = value;
  curr -> left = curr -> right = NULL;
  if(pre == NULL)

root = curr;
else

curr->value < pre->value ? pre->left=curr : pre->right=curr;
return true ;
}

4. 删除算法

    相对查找和插入复杂一点，根据待删除结点的孩子情况，分三种情况：没有孩子，只有一个孩子，有两个孩子。
    没有孩子的情况，其父结点指向空，删除该结点。
    有一个孩子的情况，其父结点指向其孩子，删除该结点。
    有两个孩子的情况，当前结点与左子树中最大的元素交换，然后删除当前结点。左子树最大的元素一定是叶子结点，交换后，当前结点即为叶子结点，删除参考没有孩子的情况。另一种方法是，当前结点与右子树中最小的元素交换，然后删除当前结点。
    代码实现分别考虑三种情况，并且每种情况考虑了待删除结点是不是根结点。虽然实现啰嗦了一些，不过情况考虑的周全，对于入门算是够了。

bool bst_delete(BSTNode *& node, int value) {
  BSTNode * 　parent = NULL;
  BSTNode * tmp;
   while (node != NULL) {
     if (value < node -> value) { // 向左
      parent = node;
      node = node -> left;
    }
     else if (value > node -> value) { // 向右
      parent = node;
      node = node -> right;
    }
     else { // 找到了
       if (NULL == node -> left && NULL == node - right) { // 叶子结点
         if (parent == NULL) { // 根结点
          delete node;
          node = NULL;
        }
         else { // 非根结点
          (parent -> left == node) ? (parent -> left = NULL):(parent -> right = NULL);
          delete node;
          node = NULL;
        }
      }
       else if (NULL != node -> left && NULL == node -> right) { // 只有左孩子
         if (parent == NULL) { // 根结点
          tmp = node;
          node = node -> left;
          delete tmp;
        }
         else { // 非根结点
          (parent -> left == node) ? (parent -> left = node -> left):(parent -> right = node -> left);
          delete node;
        }
      }
       else if (NULL != node -> right && NULL == node -> left) { // 只有右孩子
         if (parent == NULL) { // 根结点
          tmp = node;
          node = node -> right;
          delete tmp;
        }
         else { // 非根结点
          (parent -> left == node) ? (parent -> left = node -> right):(parent -> right = node -> right);
          delete node;
        }
      }
       else { // 既有左孩子也有右孩子
        BSTNode * leftNode = node;
         while (leftNode -> right != NULL) {
          parent = leftNode;
          leftNode = leftNode -> right;
        }
         // 交换leftNode与node
         int swapValue = leftNode -> value;
        leftNode -> value = node -> value;
        node -> value = swapValue;
         // 删除leftNode，parent肯定不为空
        (parent -> left == node) ? (parent -> left = NULL):(parent -> right = NULL);
        delete node;
      }
    }
  }
   return false ; // 失败
}

5. 参考

百度百科_二叉搜索树 http://baike.baidu.com/view/389453.htm