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

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