二叉排序树的C++实现（过程式）

用C的思想来写的二叉排序树。在QtCreate+win7上编译通过

头文件

#ifndef BSTree_H
#define BSTree_H
//BSTree.h
#define SUC 1
#define UNSUC 0

#include <stdlib.h>
#include <cstdio>
typedef int KeyType;
//还有另一种结构，带指向父节点的指针，编写方法时更简单，但存储耗费更大
 struct BSTNode{
    struct BSTNode* Lchild;
    struct BSTNode* Rchild;
    KeyType m_KType;

};

 typedef struct BSTNode * BSTree;
 typedef struct BSTNode * BSTNodePoint;
//插入，删除节点，删除树，遍历，查找
 bool InsertNodeByValue(BSTree&, KeyType);
 bool DeleteNodeByValue(BSTree&,KeyType);
 bool DeleteTree(BSTree&);
 const void TrivalAllTree(BSTree);
 const BSTNodePoint ResearchNodeByValue(BSTree,KeyType);

#endif

源文件

//BSTree.cpp
#include "BSTree.h"
#include <iostream>

using namespace std;

bool InsertNodeByValue(BSTree &tree, KeyType value)
{
    //使用的临时变量
    BSTNodePoint p = tree , parent = NULL;
    //创建一个新节点及初始化
    BSTNodePoint newNode = (BSTNodePoint)malloc(sizeof(BSTNode));
    newNode->m_KType = value;
    newNode->Lchild = NULL;
    newNode->Rchild = NULL;
    //空树则节点为其跟
    if( NULL == tree )
    {
        tree = newNode;
        return SUC;

    }
    //新插入的结点一定是一个新添加的叶子节点，
    //并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。
    while( NULL != p)
    {
        if( value == p->m_KType)
        {
            return UNSUC;
        }
        else
        {
            parent = p;
            p = ( p->m_KType < value )? p->Rchild : p->Lchild ;
        }
    }
    //parent是插入节点的父节点，以下判断插入其左或右孩子
    if(  value > parent->m_KType )
    {
        parent->Rchild = newNode;
    }
    else
    {
        parent->Lchild = newNode;
    }
    return SUC;


}
//后序删除树，原因：由于指针会置空，后序才能不影响释放
bool DeleteTree(BSTree& tree)
{

    if( NULL != tree)
    {

        DeleteTree(tree->Lchild);
        DeleteTree(tree->Rchild);
        cout<<"Delete key value is "<<tree->m_KType<<endl;

        free(tree);
        //置空，以防错误调用野指针
        tree = NULL;

    }
    return SUC;
}
//中序遍历，输入有序序列
 const void TrivalAllTree( BSTree tree)
{
    if( NULL != tree )
    {
        cout<<"dd";
        TrivalAllTree(tree->Lchild);
        cout<<tree->m_KType<<endl;
        TrivalAllTree(tree->Rchild);
    }


}
 const BSTNodePoint ResearchNodeByValue(BSTree tree,KeyType value)
 {
     if( NULL != tree)
     {
         if( tree->m_KType == value)
         {
             return tree;
         }
         return ResearchNodeByValue( tree->Lchild, value);
         return ResearchNodeByValue( tree->Rchild, value);

     }
     return NULL;
 }
bool DeleteNodeByValue(BSTree &tree, KeyType value)
{


    BSTNodePoint parent = NULL,p = tree,q = NULL,child = NULL;

    //循环结果：p指向了要删除的节点，parent被删除的节点的父节点
    //这里也可以使用递归实现
    while( NULL != p )
    {
        if( p->m_KType == value )
        {
            break;
        }
        else
        {
            parent = p;
            p = ( p->m_KType < value ) ? p->Rchild : p->Lchild ;
        }


    }
    if( NULL == p)
    {return UNSUC;}

    //q用于后面判断
    q = p;
    //rchild & lchild exist*/
    //转换成单个孩子的情况*/
    if( NULL != p->Lchild && NULL != p->Rchild)
    {
        parent = p;
        p = p->Rchild;
        //p指向要删除节点的右子树的最左节点，parent是p的父节点，使删除操作巧妙的转移
        while( NULL != p->Lchild)
        {
            parent = p;
            p = p->Lchild ;
        }
        child = p->Rchild;


    }
    else if( NULL != p->Lchild )
    {
        child = p->Lchild;
    }
    else if( NULL != p->Rchild )
    {
        child = p->Rchild;
    }
    else
    {
        child = NULL;
    }

    //parent被删除的节点的父节点
     //p被删除的节点
     //child被删除节点的孩子
     //

    //parent指向child*/
    if( NULL == parent)
    {
        tree = child;
    }
    else
    {
        if( p == parent->Lchild )
        {
            parent->Lchild = child;
        }
        else
        {
            parent->Rchild = child;
        }
        //发生了转换操作后，实质等同于交换节点
        if( q != p )
        {
            q->m_KType = p->m_KType;
        }
    }

    //删除
    free(p);
    p = NULL;
    return SUC;


}

 

 

测试函数

//BSTree-test-main



#include <iostream>
#include "BSTree.h"
using namespace std;

int main()
{
    cout << "Hello World!" << endl;

    BSTree tree = NULL;
    bool staus = InsertNodeByValue(tree, 3);
     InsertNodeByValue(tree, 2);
    //cout<<tree->m_KType<<endl;
    InsertNodeByValue(tree, 15);
    InsertNodeByValue(tree, 8);
    InsertNodeByValue(tree, 17);
    //TrivalAllTree(tree);
    TrivalAllTree(tree);
    bool staus2 = DeleteNodeByValue(tree,15);
    cout<<"staus2 : "<<staus2<<endl;
    TrivalAllTree(tree);
    DeleteTree(tree);
    TrivalAllTree(tree);
    return 0;
}