二叉排序树

二叉排序树（BinarySortTree）又称二叉查找树，亦称二叉搜索树。

它或者是一棵空树；或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

现在贴出对于二叉树实现的代码。

二叉树节点

BTNode.h

#include "stdafx.h"
#include <iostream>
using namespace std;
template <typename Type>class BinaryTree;
template <typename Type>
class BTNode{
public:
    friend class BinaryTree<typename Type>;
    BTNode():rchild(NULL),lchild(NULL){}
    BTNode(Type item , BTNode<Type>*r=NULL,BTNode<Type>*l=NULL):data(item),rchild(r),lchild(l){}
    Type getData()const;  // 获取数据
    BTNode<Type>* getLeft()const;  // 获取左子树
    BTNode<Type>* getRight()const;  // 获取右子树
    void setData(const Type data);  // 改变节点值
    void setLeft(const BTNode<Type>*l); // 更改左子树的值
    void setRight(const BTNode<Type>*r); // 更改右子树的值
    void inOrder();       // 中序遍历
    void preOrder();  // 前序遍历
    void postOrder();  // 后序遍历
    int size();  // 获取节点个数
    int hight();  // 计算树高
    BTNode<Type>* copy(const BTNode<Type> *copy);
    friend bool equal<Type>(const BTNode<Type> *s,const BTNode<Type> *t);
    void distroy(){  // 销毁树
        if(this !=NULL){
            this->lchild->distroy();
            this->rchild->distroy();
            delete this;
        }
    }
private:
    Type data;
    BTNode<Type>*lchild;
    BTNode<Type>*rchild;  
};
 //  获取数据
template <typename Type>
Type BTNode<Type>::getData()const{
    return (this == NULL)? -1: data;
}
 // 获取左子树
template <typename Type>
BTNode<Type>* BTNode<Type>::getLeft()const{
    return (this == NULL)? NULL:lchild;
}
//获取右子树
template <typename Type>
BTNode<Type>* BTNode<Type>::getRight()const{
    return (this == NULL)? NULL:rchild;
}

// 更改节点值
template<typename Type>
void BTNode<Type>::setData(Type data){
    if(NULL!=this){
        this->data =data;
    }
    else{
        cout<<"can't set"<<endl;
    }
}
// 更改左子树
template<typename Type> 
void BTNode<Type>::setLeft(const BTNode<Type> *left){
    if(this!=NULL){
        lchild=left;
    }
}

// 更改右子树
template<typename Type> 
void BTNode<Type>::setRight(const BTNode<Type> *right){
    if(this!=NULL){
        rchild=right;
    }
}
// 中序遍历
template<typename Type>
void BTNode<Type>::inOrder(){
    if(NULL!=this){
        this->lchild->inOrder();
        cout <<"->"<< this->data ;
        this->rchild->inOrder();
    }

}

// 前序遍历
template<typename Type>
void BTNode<Type>::preOrder(){
    if(NULL!=this){
        cout <<"->"<< this->data ;
        this->lchild->preOrder();
        this->rchild->preOrder();
    }
}
// 后序遍历
template<typename Type>
void BTNode<Type>::postOrder(){
    if(NULL!=this){
        this->lchild->postOrder();
        this->rchild->postOrder();
        cout <<"->"<< this->data ;
    }
}

// 获取树的大小
template<typename Type>
int BTNode<Type>::size(){
    if(this==NULL)return 0;
    return (1+this->lchild->size()+this->rchild->size());
}
// 计算树的高度
template<typename Type>
int BTNode<Type>::hight(){
    if(this==NULL)return -1;
    int lhight = this->lchild->hight();
    int rhight = this->rchild->hight();
    return (1+(lhight>rhight?lhight:rhight));
}
// 拷贝树
template <typename Type>
BTNode<Type>* BTNode<Type>::copy(const BTNode<Type> *copy){
    if(copy==NULL)return NULL;
    BTNode<Type>*newNode = new BTNode<Type>(copy->data);
    newNode->lchild=this->copy(copy->lchild);
    newNode->rchild=this->copy(copy->rchild);
    return newNode;
}

//判断两棵树是否相等
template<typename Type>
bool equal(const BTNode<Type> *s,const BTNode<Type> *t){
    if(s==NULL&&t==NULL){
        return 1;
    }
    if(s&&t&&s->data==t->data&&equal(s->lchild,t->lchild)&&equal(s->rchild,t->rchild)){
        return 1;
    }
    return 0;
}

二叉树实现

BinaryTree.h

#include "BTNode.h"
template<typename Type>
class BinaryTree{
public:
    BinaryTree():root(NULL){}
    BinaryTree(Type stop):m_stop(stop),root(NULL){}
    //  拷贝构造函数
    BinaryTree(BinaryTree<Type>& copy);
    //  析构函数
    virtual ~BinaryTree(){
        root->distroy();
    }
    // 判空
    virtual bool is_empty(){
        return root==NULL;
    }
     //  获取左子树
    virtual BTNode<Type>* getLeft(BTNode<Type>* current);
    // 获取右子树
    virtual BTNode<Type>* getRight(BTNode<Type>* current);
    //  获取父节点
    virtual BTNode<Type>* getParent(BTNode<Type>* current);
    // 获取根节点
    const BTNode<Type>* getRoot() const;
    // 插入一个节点
    virtual bool insert(const Type item);        
    //  查找
    virtual BTNode<Type> *find(const Type item) const;    
    void inOrder();        // 中序遍历
    void preOrder();   // 先序遍历
    void postOrder();   // 后序遍历
    int size();           // 树的大小
    int height();    // 树的高度
    BinaryTree<Type>& operator=(const BinaryTree<Type> copy);  // 树赋值
    // 判等
    friend bool operator== <Type>(const BinaryTree<Type> s,const BinaryTree<Type> t);
    // 输入树
    friend ostream& operator<< <Type>(ostream& ,BinaryTree<Type>&);    
    // 输出树
    friend istream& operator>> <Type>(istream& ,BinaryTree<Type>&);    
private:
    Type m_stop;
    BTNode<Type>*root;
    //  获取父节点
    BTNode<Type> *getParent(BTNode<Type> *start,BTNode<Type> *current);
    // 打印树
    void print(BTNode<Type> *start,int n=0);

};
template <typename Type>
BinaryTree<Type>::BinaryTree(BinaryTree<Type>& copy){
    if(copy.root){
        this->m_stop = copy.m_stop;
    }
    root=root->copy(copy.root);
}
template<typename Type>
BTNode<Type>* BinaryTree<Type>::getLeft(BTNode<Type>* current){
    return (root&&current?current->lchild:NULL);
}

template<typename Type>
BTNode<Type>* BinaryTree<Type>::getRight(BTNode<Type>* current){
    return (root&&current?current->rchild:NULL);
}

template<typename Type> 
BTNode<Type>* BinaryTree<Type>::getParent(BTNode<Type> *current){
    return root==NULL||current==root?NULL:getParent(root,current);    
}

template<typename Type>
BTNode<Type>* BinaryTree<Type>::getParent(BTNode<Type>* start,BTNode<Type>* current){
    if(start==NULL||current==NULL){
        return NULL;
    }
    if(start->rchild==current||start->lchild==current){
        return start;
    }
    return (!getParent(start->lchild,current)?getParent(start->lchild,current):getParent(start->rchild,current));
}
 //  获取root
template <typename Type>
const BTNode<Type>* BinaryTree<Type>::getRoot()const{
    return ((NULL!=root)?root:NULL);
}
// 插入节点
template <typename Type>
bool BinaryTree<Type>::insert(const Type item){
    BTNode<Type> *newNode = new BTNode<Type>(item);
    if(root==NULL){
        root = newNode;
        return 1;
    }
    BTNode<Type>*pmove = root;
    while(1){
        if(item>=pmove->data){
            if(pmove->rchild==NULL){
                pmove->rchild = newNode;
                return 1;
            }
            pmove = pmove->rchild;
        }
        else{
            if(pmove->lchild==NULL){
                pmove->lchild = newNode;
                return 1;
            }
            pmove = pmove->lchild;
        }
    }
}
// 查找 item
template<typename Type>
BTNode<Type>* BinaryTree<Type>::find(const Type item)const{
    if(root==NULL)return NULL;
    BTNode<Type> * pmove = root;
    while(pmove){
        if(item==pmove->data)return pmove;
        else if(item>pmove->data){
            pmove=pmove->rchild;
        }
        else{
            pmove = pmove->lchild;
        }
    }
    return NULL;
}
// 中序遍历
template<typename Type>
void BinaryTree<Type>::inOrder(){
    if(root==NULL){
        cout << "this is a empty tree" <<endl;
        return;
    }
    root->inOrder();
}
//先序遍历
template<typename Type>
void BinaryTree<Type>::preOrder(){
    if(root==NULL){
        cout << "this is a empty tree" <<endl;
        return;
    }
    root->preOrder();
}
//后序遍历
template<typename Type>
void BinaryTree<Type>::postOrder(){
    if(root==NULL){
        cout << "this is a empty tree" <<endl;
        return;
    }
    root->postOrder();
}

//树的大小
template <typename Type>
int BinaryTree<Type>::size(){
    if(root==NULL)return 0;
    return root->size();
}
//树的高度
template <typename Type>
int BinaryTree<Type>::height(){
    if(root==NULL)return 0;
    return root->hight();
}
// 赋值
template <typename Type>
BinaryTree<Type>& BinaryTree<Type>::operator=(const BinaryTree<Type>copy){
    if(copy->root){
        m_stop = copy.m_stop;
    }
    root = root->copy(copy.root);
    return *this;
}
// 判等
template<typename Type>
bool operator==(const BinaryTree<Type> s,const BinaryTree<Type> t){
    return equal(s.root,t.root);
}
// 输出
template<typename Type>
ostream& operator<<(ostream&os ,BinaryTree<Type>&out){
    out.print(out.root);
    return os;
}
//输入
template<typename Type>
istream& operator>>(istream&is ,BinaryTree<Type>&in){
    Type item;
    cout<<"initialize the tree:"<< endl 
        << "Input data(end with "<<in.m_stop<<"!):";
    is >>item;
    while(item!=in.m_stop){    
        in.Insert(item);
        is>>item;
    }
    return is;
}
template<typename Type> void BinaryTree<Type>::print(BTNode<Type> *start, int n){
    if(start==NULL){
        for(int i=0;i<n;i++){
            cout<<"     ";
        }
        cout<<"NULL"<<endl;
        return;
    }
    print(start->rchild,n+1);    
    for(int i=0;i<n;i++){
        cout<<"     ";
    }
    if(n>=0){
        cout<<start->data<<"->"<<endl;
    }
    print(start->lchild,n+1);
}