二叉查找树

B树是一种很有用的查找结构，能够在O(h)的时间复杂度内完成查找操作(h为树的高度)。其它操作，比如求最大，最小，前驱，后继等，复杂度均为O(h)。当树越平衡时，时间复杂度越低(O(lg(n))，因此，可以通过随机化建树，达到这一目的。另外还有一些结构，比如红黑树，其自身的性质可以保证树的平衡性，因此性能相对较好。这里我用c++实现了B树，个人认为，除了删除一个节点的操作有点复杂外，B树绝大部分操作都是很直观的，实现起来还是很容易的。代码如下：

btree.h头文件，

#ifndef _BTREE_H_
#define _BTREE_H_

class BTree
{
public:
    struct Node
    {
        int key = 0;
        Node* p = nullptr;
        Node* left = nullptr;
        Node* right = nullptr;
    };

    ~BTree();

    void inorder_walk();
    void preorder_walk();
    void postorder_walk();

    Node* search(int key);
    Node* minimum();
    Node* maximum();
    Node* successor(Node* x);
    Node* predecessor(Node* x);

    Node* insert(int key);
    void remove(Node* x);

private:
    void inorder(Node* x);
    void preorder(Node* x);
    void postorder(Node* x);
    void transplant(Node* x, Node* y);

private:
    Node* root = nullptr;
};

#endif//_BTREE_H_

 

btree.cpp实现:

#include <iostream>
#include <stack>
#include "btree.h"

using namespace std;

BTree::~BTree()
{
    stack<Node*> s;
    s.push(root);
    while (!s.empty())
    {
        Node* x = s.top(); s.pop();
        if (x != nullptr)
        {
            s.push(x->left);
            s.push(x->right);
            delete x;
        }
    }
}

void BTree::inorder(Node* x)
{
    if (x != nullptr)
    {
        inorder(x->left);
        cout << x->key << ",";
        inorder(x->right);
    }
}

void BTree::inorder_walk()
{
    inorder(root);
    cout << endl;
}

void BTree::preorder(Node* x)
{
    if (x != nullptr)
    {
        cout << x->key << ",";
        preorder(x->left);
        preorder(x->right);
    }
}

void BTree::preorder_walk()
{
    preorder(root);
    cout << endl;
}

void BTree::postorder(Node* x)
{
    if (x != nullptr)
    {
        postorder(x->left);
        postorder(x->right);
        cout << x->key << ",";
    }
}

void BTree::postorder_walk()
{
    postorder(root);
    cout << endl;
}



BTree::Node* BTree::search(int key)
{
    Node* x = root;
    while (x != nullptr && key != x->key)
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    return x;
}

BTree::Node* BTree::minimum()
{
    Node* x = root;
    while (x->left != nullptr)
    {
        x = x->left;
    }
    return x;
}

BTree::Node* BTree::maximum()
{
    Node* x = root;
    while (x->right != nullptr)
    {
        x = x->right;
    }
    return x;
}

BTree::Node* BTree::insert(int key)
{
    Node* x = root;
    Node* y = nullptr;
    while (x != nullptr)
    {
        y = x;
        if (key > x->key)
            x = x->right;
        else
            x = x->left;
    }
    Node* z = new Node;
    z->p = y;
    z->key = key;
    if (y == nullptr)
        root = z;
    else if (key < y->key)
        y->left = z;
    else
        y->right = z;
    return z;
}

void BTree::transplant(Node* x, Node* y)
{
    if (x->p == nullptr)
        root = y;
    else if (x->p->left == x)
        x->p->left = y;
    else
        x->p->right = y;
    if (y != nullptr)
        y->p = x->p;
}

void BTree::remove(Node* x)
{
    if (x->left == nullptr)
        transplant(x, x->right);
    else if (x->right == nullptr)
        transplant(x, x->left);
    else
    {
        Node* y = successor(x);
        if (y->p != x)
        {
            transplant(y, y->right);
            y->right = x->right;
            y->right->p = y;
        }
        transplant(x, y);
        y->left = x->left;
        y->left->p = y;
    }
}

BTree::Node* BTree::successor(Node* x)
{
    if (x->right != nullptr)
    {
        Node* y = x->right;
        while (y->left != nullptr)
        {
            y = y->left;
        }
        return y;
    }
    else
    {
        Node* y = x->p;
        while (y != nullptr && x == y->right)
        {
            x = y;
            y = y->p;
        }
        return y;
    }
}

BTree::Node* BTree::predecessor(Node* x)
{
    if (x->left != nullptr)
    {
        Node* y = x->left;
        while (y->right != nullptr)
        {
            y = y->right;
        }
        return y;
    }
    else
    {
        Node* y = x->p;
        while (y != nullptr && x == y->left)
        {
            x = y;
            y = y->p;
        }
        return y;
    }
}