二叉搜索树

概念介绍

http://www.cnblogs.com/QG-whz/p/4536875.html?utm_source=tuicool&utm_medium=referral（包含C++具体实现，待研究）

简单实现和测试

#pragma once
#include<iostream>
using namespace std;
struct Node
{
    int data;
    Node*Lchild, *Rchild;
};
class BSTree
{
private:
    Node*root;
public:
    BSTree() { root = NULL; }
    ~BSTree() { delete root; }
    bool FindBSTree(Node *r, int &elem);
    void InsertBSTree(Node *&r, const int elem);
    bool DeleteBSTree(Node *&r, const int &elem);
    void ConstructBSTree(int w[],int n);
    void inorder(Node *r);
    void inorder();
};

void BSTree::ConstructBSTree(int w[],int n)
{
    for (int i = 0; i < n; i++)
        InsertBSTree(root, w[i]);
}

void BSTree::inorder(Node *r)
{
    if (r != NULL)
    {
        inorder(r->Lchild);
        cout << r->data << " ";
        inorder(r->Rchild);
    }
    else
        return;
}

void BSTree::inorder()
{
    inorder(root);
}

bool BSTree::FindBSTree(Node *r, int &elem)
{
    if (r == NULL) return false;
    else
    {
        if (elem == r->data)
        {
            elem = r->data;
            return true;
        }
        else if (elem < r->data)
            return FindBSTree(r->Lchild, elem);
        else
            return FindBSTree(r->Rchild, elem);
    }
}
void BSTree::InsertBSTree(Node *&r, const int elem)
{
    if (r == NULL)
    {
        Node *p = new Node;
        p->data = elem;
        p->Lchild = NULL;
        p->Rchild = NULL;
        r = p;
    }
    else if (elem < r->data)
        InsertBSTree(r->Lchild, elem);
    else
        InsertBSTree(r->Rchild, elem);
}
bool BSTree::DeleteBSTree(Node *&r, const int &elem)
{
    if (r == NULL) return false;
    if (elem == r->data)
    {
        Node *temp = r;
        if (r->Lchild == NULL)//左子树为空，根节点变成右子树
        {
            r = r->Rchild;
            delete temp;
        }
        else if (r->Rchild == NULL)//右子树为空
        {
            r = r->Lchild;
            delete temp;
        }
        else
        {
            if (r->Lchild->Rchild == NULL)//左孩子的右子树为空，则左孩子就是根节点的中序前件
            {
                r->data = r->Lchild->data;//左子树赋给根节点
                return DeleteBSTree(r->Lchild, r->Lchild->data);//删除左子树
            }
            else//寻找左孩子的最右边的子树
            {
                Node* p1 = r, *p2 = r->Lchild;
                while (p2->Rchild != NULL)
                {
                    p1 = p2;
                    p2 = p2->Rchild;
                }
                r->data = p2->data;//把最右边那个节点赋给根节点，然后删除
                //return DeleteBSTree(p2, p2->data);//这句话不对，实际调试中现象异常诡异！！！
                return DeleteBSTree(p1->Rchild, p2->data);
            }
        }
    }
    else if (elem < r->data)
        DeleteBSTree(r->Lchild, elem);
    else
        DeleteBSTree(r->Rchild, elem);
}

测试：

#include<iostream>
#include"BST.h"
using namespace std;
int main()
{
    BSTree bst;
    int w[] = { 4,5,9,1,6,8,12,200,32,7,3,-5 };
    cout << sizeof(w) << endl;
    bst.ConstructBSTree(w, sizeof(w)/sizeof(int));
    bst.inorder();
}