something aboout binary search tree~

i implement the preorder , inorder ,postorder traversal in recursive way and iterative way , print tree , delete node , insert node.... with cpp..

// Tree.cpp : 定义控制台应用程序的入口点。
 //
 
#include "stdafx.h"
#include  <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <string>


 using namespace std;

class Node
{
public:
    Node *left_child;
    Node *right_child;
    int depth;
    int content;
    Node() : left_child ( NULL ) , right_child ( NULL ) , content ( 0 ) , depth( -1 )
    {}
    Node( int  i ) : left_child ( NULL ) , right_child ( NULL ) , content ( i ) , depth ( -1 )
    {}
    ~Node()
    {}
};

typedef Node * Tree;

Tree Insert(Tree tree, int ch)
{
    if( tree == NULL )
    {
        tree = new Node(ch);
    }
    else 
    {
        if( tree->content < ch)
        {
            tree->right_child = Insert (tree->right_child , ch);
        }
        else if( tree->content > ch)
        {
            tree->left_child = Insert (tree->left_child , ch);            
        }
    }

    return tree;
}

void Inorder(Tree tree)
{
    if( tree != NULL )
    {
        if( tree->left_child != NULL )
        {
            Inorder ( tree->left_child );
        }
        cout << tree->content<< endl;
        if( tree->right_child != NULL )
        {
            Inorder ( tree->right_child );
        }
    }
}


void Preorder(Tree tree)
{
    if( tree != NULL )
    {        
        cout << tree->content << endl;
        if( tree->left_child != NULL )
        {
            Preorder ( tree->left_child );
        }
        if( tree->right_child != NULL )
        {
            Preorder ( tree->right_child );
        }
    }
}


void Postorder(Tree tree)
{
    if( tree != NULL )
    {        
        if( tree->left_child != NULL )
        {
            Postorder ( tree->left_child );
        }
        if( tree->right_child != NULL )
        {
            Postorder ( tree->right_child );
        }    
        cout << tree->content<< endl;
    }
}


void Levelorder ( Tree tree )
{
    queue <Node> toprint;
    
    if( tree != NULL )
    {
        Node tmp;
        toprint.push( *tree );
        while( !toprint.empty() )
        {
            tmp = toprint.front();
            toprint.pop();
            cout << tmp.content << endl;
            if ( tmp.left_child != NULL )
            {
                toprint.push ( *tmp.left_child );
            }
            if ( tmp.right_child != NULL )
            {
                toprint.push ( *tmp.right_child );
            }
        }
    }
}


void Preorder_iterative ( Tree tree )
{
    if ( tree != NULL )
    {
        stack <Node> toprint;
        Node tmp = *tree;            
        toprint.push ( *tree );
        while ( !toprint.empty() )
        {
            tmp = toprint.top();
            toprint.pop();
            cout << tmp.content;
            while ( tmp.left_child != NULL )
            {
                if ( tmp.right_child != NULL )
                {
                //    cout <<endl<< "before:"<<tmp.left_child->content<<endl;
                    toprint.push(*(tmp.right_child));            
                //    cout <<endl<< "after:"<< tmp.left_child->content<<endl;
                }

                tmp = *(tmp.left_child);
                cout << tmp.content;
            }
        }
    }
}

void Postorder_iterative ( Tree tree )
{
    stack < Node > toprint;
    if ( tree != NULL )
    {
        Node flag ('0');
        Node tmp = *tree;
        toprint.push ( tmp );
        toprint.push ( flag );   //add a flag: if flag equals 0, don't print it otherwise print it;
        
        while ( !toprint.empty() )
        {
            flag = toprint.top();
            toprint.pop();
            tmp = toprint.top();
            toprint.pop();
            Tree left = tmp.left_child;
            Tree right = tmp.right_child;
            if ( ( left == NULL && right == NULL ) || ( flag.content == '1' ) )
            {
                cout << tmp.content;
                continue;
            }
            else
            {
                flag.content = '1';
                toprint.push ( tmp );
                toprint.push ( flag );

                if( right != NULL )
                {
                    Node r = *right;
                    Node rf ( '0' );
                    toprint.push ( r );
                    toprint.push ( rf );
                }

                if( left != NULL )
                {
                    Node l = *left;
                    Node lf ( '0' );
                    toprint.push ( l );
                    toprint.push ( lf );
                }
            }
        }
    }
}


// each node will be pushed onto stack twice so we need a flag the hold the times to decide whether print the node.
void Inorder_iterative ( Tree tree )
{    

    stack < Node > toprint;
    if ( tree != NULL )
    {
        Node flag ('0');
        Node tmp = *tree;
        toprint.push ( tmp );
        toprint.push ( flag );
        
        while ( !toprint.empty() )
        {
            flag = toprint.top();
            toprint.pop();
            tmp = toprint.top();
            toprint.pop();
            Tree left = tmp.left_child;
            Tree right = tmp.right_child;
            if ( ( left == NULL && right == NULL ) || ( flag.content == '1' ) )
            {
                cout << tmp.content;
                continue;
            }
            else
            {
                if( right != NULL )
                {
                    Node r = *right;
                    Node rf ( '0' );
                    toprint.push ( r );
                    toprint.push ( rf );
                }

                flag.content = '1';
                toprint.push ( tmp );
                toprint.push ( flag );
                if( left != NULL )
                {
                    Node l = *left;
                    Node lf ( '0' );
                    toprint.push ( l );
                    toprint.push ( lf );
                }
            }
        }
    }
}

//compute depth for each node and return the max depth
int GetDepth ( Tree tree , int base )
{
    int max = 0;
    if( tree != NULL )
    {
        tree->depth = base;
        max = base;
        if ( tree->left_child != NULL )
        {
            int tmp = GetDepth ( tree->left_child , base+1 );
            if ( tmp > max )
            {
                max = tmp;
            }
        }
        if ( tree->right_child != NULL )
        {
            int tmp = GetDepth ( tree->right_child , base+1 );
            if ( tmp > max )
            {
                max = tmp;
            }
        }
    }
    return max;
}

void PrintTree ( Tree tree )
{
    if ( tree != NULL )
    {
        int max = GetDepth ( tree , 0 );
        stack < Node > toprint;    
        vector < int > accesstimes ( max + 1 , 0 );   //it holds the number of node that haven't be print
        accesstimes [0] = 1;
        Node tmp = *tree;
        toprint.push ( tmp );
        while ( !toprint.empty() )
        {
            tmp = toprint.top ();
            toprint.pop();
            int d = tmp.depth;
            string line;
            line.erase();
            for(int i = 1 ; i <= 2*d ; i ++)
            {
                if(  (i/2)*2==i && i > 1 )
                {
                    int v = i/2;
                    if ( accesstimes [ v ] >0 )
                    {
                        //cout << "|";
                        line += '|';
                    }
                    else
                    {
                        line += ' ';
                    }

                }
                else 
                {
                    //cout << "     ";
                    line += ' ';
                }
            }


            //cout << "_" << tmp.content;
            line += "_";
            
            cout << line <<tmp.content << endl;

            int this_node_depth = tmp.depth;
            accesstimes [ this_node_depth ] --;

            if ( tmp.right_child != NULL )
            {
                Node r = *tmp.right_child;
                toprint.push ( r );
                accesstimes [ this_node_depth+1 ] ++;
            }
            if ( tmp.left_child != NULL )
            {
                Node l = *tmp.left_child;
                toprint.push ( l );
                accesstimes [ this_node_depth+1 ] ++;
            }
        }

    }
}

Node * SearchTree ( Tree tree , int  target )
{
    if( tree == NULL )
    {
        return NULL;
    }
    else
    {
        if ( tree->content == target )
            return tree;
        else if( tree->content < target )
        {
            return SearchTree ( tree->right_child , target );
        }
        else
        {
            return SearchTree ( tree->left_child , target );
        }
    }
}

 int FindMax ( Tree tree )
{
    if ( tree != NULL )
    {
        Node * max = tree;
        while ( max->right_child != NULL )
        {
            max = max->right_child;
        }
        
        return max->content;
    }
    else
    {
        return 0;
    }
}

int FindMin ( Tree tree )
{
    if ( tree != NULL )
    {
        Node * min = tree;
        while ( min->left_child != NULL )
        {
            min = min->left_child;
        }
        
        return min->content;
    }
    else
    {
        return 0;
    }
}


Node * DeleteNode ( Tree tree , int target )
{
    if ( tree != NULL )
    {
        if ( target == tree->content )
        {
            if ( tree->left_child && tree->right_child )
            {
                tree->content = FindMax ( tree->left_child );
                tree->left_child = DeleteNode ( tree->left_child , tree->content );
            }
            else if ( tree->left_child != NULL )
            {
                Node * tmp = tree;
                tree = tree->left_child;
                delete tmp;
            }
            else if ( tree->right_child != NULL )
            {
                Node * tmp = tree;
                tree = tree->right_child;
                delete tmp;
            }

        }
        else if  ( target < tree->content )
        {
            tree->left_child = DeleteNode ( tree->left_child , target );
        }
        else if ( target > tree->content )
        {
            tree->right_child = DeleteNode ( tree->right_child , target );
        }
    }
    return tree;
}
/*
*/

int _tmain(int argc, _TCHAR* argv[])
{
    Tree tree = NULL;
    for ( int i = 0 ; i < 40 ; i++ )
    {
        tree =  Insert ( tree , rand()%100);
    }

    //Inorder ( tree );
//    cout << endl;
    //Preorder ( tree );
//    cout << endl;    
//    Inorder_iterative ( tree );    
//    cout << endl;
//    Inorder ( tree );
//    cout << endl;
    PrintTree (tree);
    tree = DeleteNode ( tree , 34 );
    PrintTree (tree);


    //Levelorder ( tree );
    cout  << endl; 
    getchar();
    return 0;
}