二叉搜索树

一、二叉搜索树的特点

二叉搜索树的特点：对于树中的每个节点X，它的左子树中所有关键字值小于X的关键字值，而它的右子树中所有关键字值大于X的关键字值。

根据这个性质，对一个二叉树进行中序遍历，如果是单调递增的，则可以说明这个树是二叉搜索树。

LeetCode题目98:验证二叉搜索树(https://leetcode-cn.com/problems/validate-binary-search-tree/)就可以对这个二叉树进行中序遍历，然后判断是否单调递增的，如果是单调递增的，说明是二叉搜索树。否则不是二叉搜索树。

 

二、二叉搜索树的查找

过程：首先和根节点进行比较，如果等于根节点，则返回。如果小于根节点，则在根节点的左子树进行查找。如果大于根节点，则在根节点的右子树进行查找。

/* 查找以t为根节点的树中，是否包含x */
Position Find(ElementType x, SearchTree t)
{
    if (t == NULL) {
        return NULL;
    } else if (x < t->element) {
        return Find(x, t->left);
    } else if (x > t->element) {
        return Find(x, t->right);
    } else {
        return t;
    }
}

 

三、查找最大值和最小值

查找最小值：从根开始，如果有左儿子，则向左进行。直到左儿子为空，则当前节点为最小值。

Position FindMin(SearchTree t)
{
    if (t == NULL) {
        return NULL;
    } else if (t->left == NULL) {
        return t;
    } else {
        return FindMin(t->left);
    }
}

查找最大值：从根开始，如果有右儿子，则向右进行。直到右儿子为空，则当前节点为最大值。

Position FindMax(SearchTree t)
{
    if (t == NULL) {
        return NULL;
    }

    while (t->right != NULL)
    {
        t = t->right;
    }
    return t;  
}

这里查找最小值运用了递归，而查找最大值运用了非递归实现。

 

四、二叉搜索树的插入

二叉搜索树的插入过程和查找类似。新插入的节点一般在遍历的路径上的最后一点上，即叶子节点。如果待插入的数据比当前节点的数据大，并且当前节点的右儿子为空，则将待插入的节点插到右儿子位置上。如果右儿子不为空，则再递归的遍历右儿子。如果小于当前节点，则对左儿子做类似的处理就行。

SearchTree Insert(ElementType x, SearchTree t)
{
    if (t == NULL) {
        /* 插入第一个节点 */
        t = (SearchTree)malloc(sizeof(struct TreeNode));
        if (t == NULL) {
            return NULL;
        }
        t->element = x;
        t->left = NULL;
        t->right = NULL;
    } else if (x < t->element) {
        t->left = Insert(x, t->left);
    } else if (x > t->element) {
        t->right = Insert(x, t->right);
    }
    return t;
}

 

五、二叉搜索树的删除

二叉搜索树的删除分为以下几个情况：

1、待删除的节点是一个叶子节点，即它没有左右儿子。此时只要将它的父节点指向NULL即可。

2、如果节点有一个儿子，则该节点可以在其父节点调整指针绕过该节点后删除。

3、如果有两个儿子，一般的删除策略是用其右子树中最小的数据代替该节点的数据并递归地删除那个节点。因为右子树中最小地节点不可能有左儿子(如果有，则说明不是最小的)，所以第二次删除更容易。(其实也就是将有两个儿子的情况转为容易处理的情况1或者2)。

/* 删除策略
 * 1、如果待删除节点只有一个儿子，则将该节点的父节点的儿子节点指针指向该节点的儿子节点，
 * 然后删除该节点.
 * 2、如果待删除节点有两个儿子，用右子树中最小的数据代替该节点的数据并递归地删除那个节点。
 * 因为右子树中最小地节点不可能有左儿子，所以第二次删除更容易.
 */
 SearchTree Delete(ElementType x, SearchTree t)
 {
     Position tmp;
     if (t == NULL) {  
         return NULL;
     }
     if (x < t->element) {
         t->left = Delete(x, t->left);
     } else if (x > t->element) {
         t->right = Delete(x, t->right);
     } else if (t->left && t->right) {
         tmp = FindMin(t->right);
         t->element = tmp->element;
         t->right = Delete(t->element, t->right);
     } else {
         tmp = t;
         if (t->left) {
             t = t->left;
         } else if (t->right) {
             t = t->right;
         }
         free(tmp);
         tmp = NULL;
     }
     return t;
 }

六、建立一棵空树

SearchTree MakeEmpty(SearchTree t)
{
    if (t != NULL) {
        MakeEmpty(t->left);
        MakeEmpty(t->right);
        free(t);
        t = NULL;
    }
    return NULL;
}

附录：

完整代码：

#include <stdio.h>
#include <stdlib.h>

#define ElementType int
struct TreeNode;
typedef struct TreeNode *Position;
typedef struct TreeNode *SearchTree;

SearchTree MakeEmpty(SearchTree t);
Position Find(ElementType x, SearchTree t);
Position FindMin(SearchTree t);
Position FindMax(SearchTree t);
SearchTree Insert(ElementType x, SearchTree t);
SearchTree Delete(ElementType x, SearchTree t);

struct TreeNode
{
    ElementType element;
    SearchTree left;
    SearchTree right;
};

SearchTree MakeEmpty(SearchTree t)
{
    if (t != NULL) {
        MakeEmpty(t->left);
        MakeEmpty(t->right);
        free(t);
        t = NULL;
    }
    return NULL;
}

/* 查找以t为根节点的树中，是否包含x */
Position Find(ElementType x, SearchTree t)
{
    if (t == NULL) {
        return NULL;
    } else if (x < t->element) {
        return Find(x, t->left);
    } else if (x > t->element) {
        return Find(x, t->right);
    } else {
        return t;
    }
}

Position FindMin(SearchTree t)
{
    if (t == NULL) {
        return NULL;
    } else if (t->left == NULL) {
        return t;
    } else {
        return FindMin(t->left);
    }
}

Position FindMax(SearchTree t)
{
    if (t == NULL) {
        return NULL;
    }

    while (t->right != NULL)
    {
        t = t->right;
    }
    return t;  
}

SearchTree Insert(ElementType x, SearchTree t)
{
    if (t == NULL) {
        /* 插入第一个节点 */
        t = (SearchTree)malloc(sizeof(struct TreeNode));
        if (t == NULL) {
            return NULL;
        }
        t->element = x;
        t->left = NULL;
        t->right = NULL;
    } else if (x < t->element) {
        t->left = Insert(x, t->left);
    } else if (x > t->element) {
        t->right = Insert(x, t->right);
    }
    return t;
}

/* 删除策略
 * 1、如果待删除节点只有一个儿子，则将该节点的父节点的儿子节点指针指向该节点的儿子节点，
 * 然后删除该节点.
 * 2、如果待删除节点有两个儿子，用右子树中最小的数据代替该节点的数据并递归地删除那个节点。
 * 因为右子树中最小地节点不可能有左儿子，所以第二次删除更容易.
 */
 SearchTree Delete(ElementType x, SearchTree t)
 {
     Position tmp;
     if (t == NULL) {  
         return NULL;
     }
     if (x < t->element) {
         t->left = Delete(x, t->left);
     } else if (x > t->element) {
         t->right = Delete(x, t->right);
     } else if (t->left && t->right) {
         tmp = FindMin(t->right);
         t->element = tmp->element;
         t->right = Delete(t->element, t->right);
     } else {
         tmp = t;
         if (t->left) {
             t = t->left;
         } else if (t->right) {
             t = t->right;
         }
         free(tmp);
         tmp = NULL;
     }
     return t;
 }

 void PrintfTree(SearchTree t)
 {
     if (t == NULL) {
         return;
     }
     printf("%d ", t->element);
     PrintfTree(t->left);
     PrintfTree(t->right);
     return;
 }

 int main()
 {
     ElementType i;
     SearchTree binary_tree = NULL;

     /******** Insert *********/
     for (i = 1; i < 11; i++) {
         binary_tree = Insert(i, binary_tree);
     }
     PrintfTree(binary_tree);
     printf("
");

    /******** Find *********/
     Position pos = NULL;
     pos = Find(6, binary_tree);
     if (pos != NULL) {
         printf("find %d
", pos->element);
     } else {
         printf("Not find 6
");
     }
     pos = Find(11, binary_tree);
     if (pos != NULL) {
         printf("find %d
", pos->element);
     } else {
         printf("Not find 11
");
     }

    /******** FindMin *********/
     Position min = NULL;
     min = FindMin(binary_tree);
     if (min) {
         printf("find min, min: %d
", min->element);
     } else {
         printf("not find min
");
     }

    /******** FindMax *********/
     Position max = NULL;
     max = FindMax(binary_tree);
     if (max) {
         printf("find max, max: %d
", max->element);
     } else {
         printf("not find max
");
     }


    Position del = NULL;
    del = Delete(8, binary_tree);
    PrintfTree(binary_tree);
    printf("
");

    binary_tree = MakeEmpty(binary_tree);
    PrintfTree(binary_tree);
    return 0;
 }