基础算法--二叉排序树

基础算法–二叉排序树

定义

首先我们来看一下二叉排序树的定义，二叉排序树应该是一颗空树或者满足如下性质

• 若左子树不空，则左子树上所有结点的值均小于它的根结点的值
• 若右子树不空，则右子树上所有结点的值均大于它的根结点的值
• 左、右子树也分别为二叉排序树

上图即为一个二叉排序树，该二叉树的中序遍历结果为$20,25,28,29,30,33,35,40$

操作

二叉排序树有关的操作主要包括插入，遍历，查找，删除。这些操作的时间复杂度都应该是$O(h)$，其中$h$为二叉树的高度。首先我们定义树的节点

struct Node {
    Node *left;
    Node *right;
    int val;
    Node(int v) {
        val = v;
    }
};

插入

插入一个结点只需要找到该插入结点的位置，如插入$27$这个结点，先从树根开始，$30$是大于$27$的，这时$27$应该插入到根结点的左子树，又因为根结点的左子树不为空，所以继续向下移动，找到$28$，把$28$作为根节点继续比较，直到找到一个根节点，该根节点的左子树或右子树是空的，且空着的位置正好是要插入的结点的位置，就停止。不难看出时间复杂度为$O(h)$。

void insert(Node *tree, int val) {
    Node *parent = tree;
    while (tree) {
        parent = tree;
        if (tree->val > val) {
            tree = tree->left;
        } else {
            tree = tree->right;
        }
    }
    if (parent->val > val) {
        parent->left = new Node(val);
    } else {
        parent->right = new Node(val);
    }
}

查找

根据二叉搜索树的性质，根节点大于左子树，小于右子树。因此我们可以将二叉搜索树的查找总结为三步

• 若等于根节点则成功返回
• 如果小于根节点，则查其左子树
• 否则查其右子树

不难分析出，查找的时间复杂度为$O(h)$

bool search(Node *root, int val) {
    if (!root) return false;
    if (root->val == val) return true;
    if (root->val > val) {
        return search(root->left, val);
    } else {
        return search(root->right, val);
    }
}

遍历

遍历二叉搜索树其实就是二叉树的中序遍历

void visit(Node *root) {
    if (!root) return;
    visit(root->left);
    std::cout << root->val << " ";
    visit(root->right);
}

删除

删除结点的操作相对上面操作会复杂一些。删除一个节点我们需要分三个种情况讨论：

• 删除一个没有孩子的结点，只需要简单的删除即可
• 删除只有一个孩子的结点，只需把它的唯一的孩子提升放在它的位置即可
• 删除有两个孩子的结点复杂一点：
  • 找到删除节点右子树的最小节点，根据二叉搜索树的性质，我们的到两个结论
    • 右子树上的最小节点必定为此子树的叶子节点
    • 右子树上的任一节点都大于左子树上的所有节点
  • 使用右子树上的最小节点替代删除节点位置，此时新的二叉树依然是一个二叉搜索树

Node *del(Node *root, int val) {
    if (!root) return root;
    Node *parent = nullptr;
    Node *tmp = root;
    while (tmp && tmp->val != val) {
        parent = tmp;
        if (tmp->val > val) {
            tmp = tmp->left;
        } else {
            tmp = tmp->right;
        }
    }
    if (!tmp) return root;
    if (tmp->left && tmp->right) {
        Node *right_min_node = tmp->right;
        Node *_parent = tmp;
        while (right_min_node) {
            if (right_min_node->left) {
                _parent = right_min_node;
                right_min_node = right_min_node->left;
                continue;
            }
            break;
        }
        right_min_node->left = tmp->left;
        if (!parent) {
            root = right_min_node;
        } else {
            if (parent->val > tmp->val) {
                parent->left = right_min_node;
            } else {
                parent->right = right_min_node;
            }
        }
        delete tmp;
        return root;
    } else if (tmp->left) {
        if (parent) {
            parent->left = tmp->left;
        } else {
            root = tmp->left;
        }
        delete tmp;
        return root;
    } else if (tmp->right) {
        if (parent) {
            parent->right = tmp->right;
        } else {
            root = tmp->right;
        }
        delete tmp;
        return root;
    } else {
        if (parent) {
            if (parent->val > tmp->val) {
                parent->left = nullptr;
            } else {
                parent->right = nullptr;
            }
            delete tmp;
            return root;
        } else {
            return nullptr;
        }
    }
}

注意：需要考虑删除节点正好是根节点的情况

析构

因为上面插入使用了new，因此我们需要使用delete来释放内存

void destory(Node *root) {
    if (!root) return;
    destory(root->left);
    destory(root->right);
    delete root;
}

思考

• 我们使用二叉搜索树，往往是为了利用其查找优势，查找时间复杂度为$O(h)$。如果二叉搜索树是一颗完全二叉树那么查找时间复杂度将会降低到$O(lo{g}_{2}n)$，$n$为元素个数。但是我们在建立二叉树的时候，如果输入元素是降序或者升序的，那么二叉搜索树将会退化为链表，此时查找时间复杂度将为上升到$O(n)$。那么我们应该如何解决这种高度不平衡带来的问题呢？