二叉排序树binary_sort_tree

当你希望获取快速的查找时间，快速的插入删除时间，并且遍历是有序的 数据结构， 你需要的就是二叉排序树了。

AVL二叉平衡树，红黑树都是binary sort tree,  这就是STL中的map为什么（中序）遍历，key是有序输出的原因！

注意： 二叉排序树，平均插入，查找O(logn), 但如果不平衡，极端情况，查找为O(n), 一棵斜树。 所以，利用平衡可以提高效率。

为了简化，仅列出一般的binary sort tree 的常用函数编码， 暂时不考虑平衡因素。主要包括：: 构建，查找，插入，删除

代码实现：C++语言: 贴彩色代码可用：http://fayaa.com/code/new/

BinarySortTree.h:

C++语言:  高亮代码由发芽网提供

/*
简化操作， 不考虑data相等情况，即所有左子树均小于根节点，所有右子树均大于跟节点
*/
#include <iostream>

typedef struct BinaryTreeNode
{
     int data;
    BinaryTreeNode * lchild;
    BinaryTreeNode * rchild;
} BinaryTreeNode, *BinaryTree;

class BinarySortTree
{
public:
    BinarySortTree();
    ~BinarySortTree( void);

     void InsertNode( int data);
     void DeleteNode( int data);
     void BuildBinarySortTree( int * data_array,  int size);
     bool Find( int data);
     // 中序遍历打印
     void PrintTree( void);

private:
     void InsertNode(BinaryTree & root,  int data);
     void DeleteNode(BinaryTree & node);
     void DeleteNode(BinaryTree & root,  int data);
     bool Find(BinaryTree root,  int data);
     void PrintTree(BinaryTree root);
     void ClearTree(BinaryTree root);
    BinaryTree root_;
};

BinarySortTree.cpp:

C++语言: 高亮代码由发芽网提供

#include "BinarySortTree.h"

using namespace std;

BinarySortTree::BinarySortTree(): root_(NULL)
{
}

BinarySortTree::~BinarySortTree( void)
{
    ClearTree(root_);
}

void BinarySortTree::BuildBinarySortTree( int * data_array,  int size)
{
     for ( int i= 0; i<size; ++i)
    {
         int data = data_array[i];
        InsertNode(root_, data);
    }
}

void BinarySortTree::InsertNode( int data)
{
    InsertNode(root_, data);
}

// 必须传引用，否则不能链接新节点。
void BinarySortTree::InsertNode(BinaryTree & root,  int data)
{
    BinaryTreeNode * key = root;
    BinaryTreeNode * parent = key;
     // 递归可以很容易实现，非递归效率更高
     while (key != NULL)
    {
        parent = key;
         if (data < key->data)
        {
            key = key->lchild;
        }
         else if (data > key->data)
        {
            key = key->rchild;
        }
         else
        {  // 已有data，不再插入
             return;
        }
    }
     // key == NULL, 创建节点
    key =  new BinaryTreeNode();
    key->data = data;
    key->lchild = NULL;
    key->rchild = NULL;
     // 将新创建的节点，连入树中
     if (parent != NULL)
    {
         if (data < parent->data)
        {
            parent->lchild = key;
        }
         else if (data > parent->data)
        {
            parent->rchild = key;
        }
    } 
     else
    {
         // 传引用的原因！！
        root = key;
    }
}

void BinarySortTree::DeleteNode( int data)
{
    DeleteNode(root_, data);
}

void BinarySortTree::DeleteNode(BinaryTree & root,  int data)
{
     if (root == NULL)
    {
        cout <<  "Delete operation CANNOT find "<< data <<  " in this binary sort tree" << endl;
         return;
    }
     if (data < root->data)
    {
        DeleteNode(root->lchild, data);
    }
     else if (data > root->data)
    {
        DeleteNode(root->rchild, data);
    }
     else  // find data
    {
        DeleteNode(root);
    }
}

void BinarySortTree::DeleteNode(BinaryTree & node)
{
     if (node == NULL)
    { // shoulde come here
        cout << "SHOULD NOT deleting a null Node!! " << endl;
         return;
    }
    BinaryTreeNode * delete_node = node;
     if (node->rchild == NULL)
    { // 如果只有左子树，直接删除节点，并将左子树挂接到父节点
        node = node->lchild;
         delete delete_node;
    }
     else if (node->lchild == NULL)
    { // 如果只有右子树，直接删除节点，并将右子树挂接到父节点
        node = node->rchild;
         delete delete_node;
    }
     else
    { // 如果左右子树均存在，找直接前驱，替换节点
        BinaryTreeNode * delete_node_parent = node;
        delete_node = node->lchild;
         while (delete_node->rchild != NULL)
        {
            delete_node_parent = delete_node;
            delete_node = delete_node->rchild;
        }
        node->data = delete_node->data; // 完成节点交换
        // 重新建立节点的链接
         if (delete_node_parent->rchild == delete_node)
        {
            delete_node_parent->rchild = delete_node->lchild;
        }
         else 
        {
            delete_node_parent->lchild = delete_node->lchild;
        }
         delete delete_node;
    }
}

bool BinarySortTree::Find( int data)
{
     return Find(root_, data);
}

bool BinarySortTree::Find(BinaryTree root,  int data)
{
     if (root == NULL)
    {
         return false;
    }
     if (data == root->data)
    {
         return true;
    }
     else if (data < root->data)
    {
        Find(root->lchild, data);
    }
     else if (data > root->data)
    {
        Find(root->rchild, data);
    }
}

void BinarySortTree::PrintTree( void)
{
    PrintTree(root_);
    cout << endl;
}

void BinarySortTree::PrintTree(BinaryTree root)
{
     if (root_ == NULL)
    {
        cout<< "This is an empty tree!" << endl;
         return;
    }
     if (root == NULL)
    {
         return;
    }
    BinaryTreeNode * p_node = root;
     // 递归实现中序遍历, 也可以借用栈非递归实现
    PrintTree(p_node->lchild);
    cout << p_node->data <<  " \t ";
    PrintTree(p_node->rchild);
}

void BinarySortTree::ClearTree(BinaryTree root)
{
     if (root == NULL)
    {
         return;
    }
     if (root->lchild != NULL)
    {
        ClearTree(root->lchild);
    }
     if (root->rchild != NULL)
    {
        ClearTree(root->rchild);
    }
     // 删除节点
     delete root;
}

main.cpp  测试代码：

C++语言:  高亮代码由发芽网提供

#include <iostream>
#include "BinarySortTree.h"

int main( int argc,  const char ** argv)
{
     int test_array[] = { 62,  88,  58,  47,  35,  73,  51,  99,  37,  93};
     int arr_size =  sizeof(test_array)/ sizeof( int);
    BinarySortTree tree;
    tree.BuildBinarySortTree(test_array, arr_size);
    tree.PrintTree();
     if (tree.Find( 35))
    {
        tree.DeleteNode( 35);
    }
     if (tree.Find( 62))
    {
        tree.DeleteNode( 62);
    }
     if (tree.Find( 87))
    {
        tree.DeleteNode( 87);
    }
     if (tree.Find( 35))
    {
        tree.DeleteNode( 37);
    }
    tree.PrintTree();
    tree.DeleteNode( 189);

     return  0;
}

运行结果：