二叉搜索树BinarySearchTree（C实现）

头文件——————————————————————————————
#ifndef     _BINARY_SEARCH_TREE_H_
#define     _BINARY_SEARCH_TREE_H_

#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <stack>
#include <set>

#define Element int
struct TreeNode
{
     Element data;
     struct TreeNode *left;
     struct TreeNode *right;
};
typedef struct TreeNode *Position;
typedef     Position BinarySearchTree;

void MakeEmpty(BinarySearchTree* pbst);
Position Find(Element x, BinarySearchTree bst);
Position FindMin(BinarySearchTree bst);
Position FindMax(BinarySearchTree bst);
void Insert(Element x, BinarySearchTree* pbst);
void Delete(Element x, BinarySearchTree* pbst);
Element Retrieve(Position p);

void PrintTree(BinarySearchTree bst, int Depth, int ctrl);
void PreOrder(BinarySearchTree bst);
void InOrder(BinarySearchTree bst);
void PostOrder(BinarySearchTree bst);
void PreOrderNotRecursion(BinarySearchTree bst);
void InOrderNotRecursion(BinarySearchTree bst);
void PostOrderNotRecursion(BinarySearchTree bst);

#endif
源文件——————————————————————————————
#include "BinarySearchTree.h"

void MakeEmpty(BinarySearchTree* pbst)
{
     if(NULL != (*pbst))
     {
          MakeEmpty(&((*pbst)->left));
          MakeEmpty(&((*pbst)->right));
          free(*pbst);
          *pbst = NULL;
     }
     return ;
}
Position Find(Element x, BinarySearchTree bst)
{
     while(NULL != bst)
     {
          if(x < Retrieve(bst))
               bst = bst->left;
          else if(x > Retrieve(bst))
               bst = bst->right;
          else
               break;
     }
     return bst;
}
Position FindMin(BinarySearchTree bst)
{
     while(NULL != bst && NULL != bst->left)
          bst = bst->left;
     return bst;
}
Position FindMax(BinarySearchTree bst)
{
     while(NULL != bst && NULL != bst->right)
          bst = bst->right;
     return bst;
}
void Insert(Element x, BinarySearchTree* pbst)
{
     if(NULL == *pbst)
     {
          Position tmp = (Position)malloc(sizeof(struct TreeNode));
          if(NULL == tmp)
               return ;
          tmp->data = x;
          tmp->left = tmp->right = NULL;
          *pbst = tmp;
     }
     else if(x < (*pbst)->data)
          Insert(x, &((*pbst)->left));
     else if(x > (*pbst)->data)
          Insert(x, &((*pbst)->right));
     else
          return ;
}
void Delete(Element x, BinarySearchTree* pbst)
{
     if(NULL == *pbst)
          return ;
     if(x < (*pbst)->data)//go left
          Delete(x, &((*pbst)->left));
     else if(x > (*pbst)->data)//go right
          Delete(x, &((*pbst)->right));
     else     //the x is found, the *pbst points to the x
     {
          if(NULL != (*pbst)->left && NULL != (*pbst)->right)//the x has two children
          {
               Position tmp = FindMin((*pbst)->right);
               (*pbst)->data = tmp->data;
               Delete((*pbst)->data, &((*pbst)->right));
          }
          else     //the x has one or none child
          {
               Position tmp = (*pbst);
               if(NULL != (*pbst)->left)          //the x has left child
                    (*pbst) = tmp->left;
               else if(NULL != (*pbst)->right)     //the x has right child
                    (*pbst) = tmp->right;
               else                                    //the x has none child
                    (*pbst) = NULL;
               free(tmp);
          }
     }
}
Element Retrieve(Position p)
{
     return p->data;
}
void PrintTree(BinarySearchTree bst, int Depth, int ctrl)//ctrl:0=root 1=left 2=right
{

     if(NULL != bst)
     {
          std::cout<<std::setw(Depth);
          if(0 == ctrl)
               std::cout<<"rt:";
          else if(1 == ctrl)
               std::cout<<"l";
          else if(2 == ctrl)
               std::cout<<"r";
          std::cout<<bst->data<<std::endl;
          PrintTree(bst->left, Depth+3, 1);
          PrintTree(bst->right, Depth+3, 2);
     }
}
void PreOrder(BinarySearchTree bst)
{
     if(NULL != bst)
     {
          std::cout<<bst->data<<"-";
          PreOrder(bst->left);
          PreOrder(bst->right);
     }
}
void InOrder(BinarySearchTree bst)
{
     if(NULL != bst)
     {
          InOrder(bst->left);
          std::cout<<bst->data<<"-";
          InOrder(bst->right);
     }
}
void PostOrder(BinarySearchTree bst)
{
     if(NULL != bst)
     {
          PostOrder(bst->left);
          PostOrder(bst->right);
          std::cout<<bst->data<<"-";
     }
}
void InOrderNotRecursion(BinarySearchTree bst)//二叉查找数的非递归版中序遍历，利用栈来模拟函数递归调用
{
     std::stack<Position> s;
     while(NULL != bst)//沿着最左的方向将左儿子依次压入栈中
     {
          s.push(bst);
          bst = bst->left;
     }
     while(!s.empty())
     {
          Position pos = s.top();
          s.pop();
          std::cout<<pos->data<<"-";
          if(NULL != pos->right)//pos has right child
          {
               pos = pos->right;
               while(NULL != pos)//沿着最左的方向将左儿子依次压入栈中
               {
                    s.push(pos);
                    pos = pos->left;
               }
          }
     }
}
void PreOrderNotRecursion(BinarySearchTree bst)//二叉查找数的非递归版先序遍历
{
     std::stack<Position> s;
     s.push(bst);
     while(!s.empty())
     {
          Position pos = s.top();
          s.pop();
          std::cout<<pos->data<<"-";
          if(NULL != pos->right)//如果pos有右儿子就先将其右儿子压入栈中
               s.push(pos->right);
          if(NULL != pos->left)//如果pos有左儿子就再将其左儿子压入栈中
               s.push(pos->left);
     }
}
void PostOrderNotRecursion(BinarySearchTree bst)//二叉查找数的非递归版后序遍历
{
     std::stack<Position> s;
     std::set<Position> rchild_visited;
     while(NULL != bst)//沿着最左的方向将左儿子依次压入栈中
     {
          s.push(bst);
          bst = bst->left;
     }
     while(!s.empty())
     {
          Position pos = s.top();
          //s.pop();
          if(NULL == pos->right)//pos没有右儿子因此可以直接访问pos
          {
               std::cout<<pos->data<<"-";
               s.pop();
          }
          else if(rchild_visited.find(pos) == rchild_visited.end())
          {//pos有右儿子我们不可以访问pos，需要先访问完其右子树后才可访问pos
          //因此要进入其右儿子中递归访问右子树同时标记pos的右儿子已经被我们访问过了
               rchild_visited.insert(pos);
               pos = pos->right;
               while(NULL != pos)//把右子树的根连同其左儿子沿着左儿子的方向依次压入栈中
               {
                    s.push(pos);
                    pos = pos->left;
               }
          }
          else if(rchild_visited.find(pos) != rchild_visited.end())
          {//此时pos右儿子已经被访问过了因此我们可以直接访问pos了
               std::cout<<pos->data<<"-";
               rchild_visited.erase(pos);
               s.pop();
          }
     }
}