二叉树遍历的一些代码

// binary_tree.cpp : Defines the entry point for the console application.
//
#include<iostream>
#include<stack>
#include<queue>
using namespace std;
class binary_node
{
public:
    int value;
    binary_node *left,*right;

    binary_node(){};
    binary_node(int v,binary_node*l ,binary_node* r)
    {
        value = v;
        left = l;
        right = r;
    }
    void visit()
    {
        cout<<value<<' ';
    }
};

void pre_order_r(binary_node* root)
{
    static int count = 0;
    count++;
    //cout<<count<<' ';
    //if(root == NULL)
    //    return;
    root->visit();
    if(root->left)
        pre_order_r(root->left);
    if(root->right)
        pre_order_r(root->right);
}

void in_order_r(binary_node* root)
{
    //if(root == NULL)
    //    return;
    if(root->left)
        in_order_r(root->left);
    root->visit();
    if(root->right)
        in_order_r(root->right);
}

void post_order_r(binary_node* root)
{
    //if(root == NULL)
    //    return;
    if(root->left)
        post_order_r(root->left);
    if(root->right)
        post_order_r(root->right);
    root->visit();
}

void pre_order_nr(binary_node * root)
{
    stack<binary_node*> bin_stack;
    int count = 0;
    while(root != NULL || !bin_stack.empty())
    {
        count++;
        if(root == NULL)
        {
            root = bin_stack.top();
            bin_stack.pop();
        }
        else
        {
            root->visit();
            bin_stack.push(root->right);
            root = root->left;
        }
    }
    cout<<"count = "<<count;
}

void pre_order_nr2(binary_node *root)
{
    stack<binary_node*> bin_stack;
    int count = 0;
    bin_stack.push(NULL);
    while(root != NULL)
    {
        count++;
        {
            root->visit();
            if(root->right)
                bin_stack.push(root->right);
            if(root->left)
                root = root->left;
            else{
                root = bin_stack.top();
                bin_stack.pop();
            }
        }
    }
    cout<<"count = "<<count;
}

void in_order_nr(binary_node* root)
{
    stack<binary_node*> bin_stack;
    int count = 0;
    while(root != NULL || !bin_stack.empty())
    {
        count++;
        if(root == NULL)
        {
            root = bin_stack.top();
            bin_stack.pop();
            root->visit();
            root = root->right;
        }
        else
        {
            bin_stack.push(root);
            root = root->left;
        }
    }
    cout<<"count = "<<count;
}

void in_order_nr2(binary_node* root)//这样好像不行
{
    stack<binary_node*> bin_stack;
    int count = 0;
    while(root != NULL || !bin_stack.empty())
    {
        count++;
        if(root == NULL)
        {
            root = bin_stack.top();
            bin_stack.pop();
            root->visit();
            if(root->right)
                root = root->right;
        }
        else
        {
            bin_stack.push(root);
            if(root->left)
                root = root->left;
        }
    }
    cout<<"count = "<<count;
}

void level_order(binary_node *root)
{
    queue<binary_node*> bin_queue;
    bin_queue.push(root);
    while(!bin_queue.empty())
    {
        root = bin_queue.front();
        bin_queue.pop();
        root->visit();    
        if(root->left)
            bin_queue.push(root->left);
        if(root->right)
            bin_queue.push(root->right);    
    }
}

void level_order2(binary_node *root)//这个方法明显不如上一种简洁，有点软件流水线的感觉。。。
{
    queue<binary_node*> bin_queue;
    do
    {        
        if(root->left)
            bin_queue.push(root->left);
        if(root->right)
            bin_queue.push(root->right);    
        root->visit();
        if(!bin_queue.empty())
        {
            root = bin_queue.front();
            bin_queue.pop();    
        }
    }while(!bin_queue.empty());
    root->visit();
}

void level_order3(binary_node *root)//还是第一种最简洁
{
    queue<binary_node*> bin_queue;
    while(!bin_queue.empty() || root)
    {
        if(root == NULL)
        {
            root = bin_queue.front();
            bin_queue.pop();
        }
        else{
            root->visit();
            bin_queue.push(root->left);
            bin_queue.push(root->right);    
        }
        if(!bin_queue.empty())
        {
            root = bin_queue.front();
            bin_queue.pop();
        }
    }
}

int main()
{
    const int size = 7;
    binary_node *node_array = new binary_node[size]();//写成node_array[]就不行
    int i;
    for(i = 0; i < size/2; i++)
    {
        node_array[i].value = i;
        node_array[i].left = &node_array[2 * i + 1];
        node_array[i].right = &node_array[2 * i + 2]; 
    }
    for(i;i<size;i++)
    {
        node_array[i].value = i;
        node_array[i].left = node_array[i].right = NULL;
    }
    cout<<"pre_r: ";
    pre_order_r(&node_array[0]);
    cout<<endl;

    cout<<"pre_nr: ";
    pre_order_nr(&node_array[0]);
    cout<<endl;

    cout<<"pre_nr2: ";
    pre_order_nr2(&node_array[0]);
    cout<<endl;

    cout<<"in_r: ";
    in_order_r(&node_array[0]);
    cout<<endl;

    cout<<"in_nr: ";
    in_order_nr(&node_array[0]);
    cout<<endl;

    cout<<"post_r: ";
    post_order_r(&node_array[0]);
    cout<<endl;

    cout<<"level:";
    level_order(&node_array[0]);
    cout<<endl;

    cout<<"level2:";
    level_order2(&node_array[0]);
    cout<<endl;

    cout<<"level3:";
    level_order3(&node_array[0]);
    cout<<endl;

    return 0;
}