算法导论第三版--二叉搜索树

看到二叉搜索树，就会回想到当年在大学课堂学习数据结构的情景，真的是悠悠岁月，欲说当年好困惑。

二叉树的可以参考的资料繁多，这里就不多说了，非要说的话，请看算法导论第12章吧。

下面是代码，包含了一点点C++11的特性。

1、二叉树遍历，没有比递归实现更优雅简洁直观的了，非要说非递归就是好的话我也赞成，反正大家开心就好：

template<typename T>
void inorder_tree_walk(bst_node_cls<T>* x) {
    if(x != nullptr) {
        inorder_tree_walk(x->left);
        cout << x->key << " ";
        inorder_tree_walk(x->right);
    }
}

2、如何描述二叉树的根节点和其他子节点：

template<typename T>
struct bst_node {
    typedef bst_node<T> __node;
    __node* parent;
    __node* left;
    __node* right;
    T key;
    void *data;
};

template<typename T> using bst_node_cls = bst_node<T>;

template<typename T>
struct binary_search_tree {
   bst_node_cls<T>* root;
};

template<typename T> using bst_cls = binary_search_tree<T>;

3、二叉树的最小关键值和最大关键值

template<typename T>
bst_node_cls<T>* tree_minimum(bst_node_cls<T>* node) {
    while(node->left != nullptr)
        node = node->left;
    return node;
}

template<typename T>
bst_node_cls<T>* tree_maximum(bst_node_cls<T>* node) {
    while(node->right != nullptr)
        node = node->right;
    return node;
}

4、某个节点的后继与前驱。

后继就是key值比这个节点的key值就大那么一点点，不能更多了；前驱就是key值比这个节点的key值小那么一点点，不能更小了。

template<typename T>
bst_node_cls<T>* tree_successor(bst_node_cls<T>* node) {
    bst_node_cls<T>* y = nullptr;

    if(node->right != nullptr)
        return tree_minimum(node->right);

    y = node->parent;
    while(y != nullptr && node == y->right) {
        node = y;
        y = y->parent;
    }

    return y;
}

template<typename T>
bst_node_cls<T>* tree_presuccessor(bst_node_cls<T>* node) {
    bst_node_cls<T>* y = nullptr;

    if(node->left != nullptr)
        return tree_maximum(node->left);

    y = node->parent;
    while(y != nullptr && node == y->left) {
        node = y;
        y = y->parent;
    }

    return y;
}

5、节点的插入与删除

template<typename T>
void tree_insert(bst_cls<T>& tree, bst_node_cls<T>* z) {
    bst_node_cls<T>  *y = nullptr;
    bst_node_cls<T>  *x = tree.root;

    while (x != nullptr) {
        y = x;
        x = (z->key < x->key) ? x->left : x->right;
    }

    z->parent = y;
    if (y == nullptr) {
        tree.root = z;
    } else if (z->key < y->key){
        y->left = z;
    } else {
        y->right = z;
    }
}

template<typename T>
void transplant(bst_cls<T>& tree, bst_node_cls<T>* u, bst_node_cls<T>* v) {
    if(u->parent == nullptr)
        tree.root = v;
    else if (u == u->parent->left) {
        u->parent->left = v;
    } else {
        u->parent->right = v;
    }

    if(v != nullptr)
        v->parent = u->parent;
}

template<typename T>
void tree_delete(bst_cls<T>& tree, bst_node_cls<T>* z) {
    bst_node_cls<T>* y;

    if(z->left == nullptr) {
        transplant(tree, z, z->right);
    } else if(z->right == nullptr) {
        transplant(tree, z, z->left);
    } else {
        y = tree_minimum(z.right);
        if(y.parent != z) {
            transplant(tree, y, y->right);
            y->right = z->right;
            y->right->parent = y;
        }
        transplant(tree, z, y);
        y->left = z->left;
        y->left->parent = y;
    }
}