二叉树

二叉树的定义，及前、中、后、层、递归、非递归遍历。

如下：

#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <queue>

using namespace std;

struct Node{
    int data;
    Node* left;
    Node* right;
    Node(){}
    Node(int d){
        data = d;
        left = NULL;
        right = NULL;
    }
};

//pre order travel
void preorder(Node* root){
    if(root==NULL) return;
    printf("%d ",root->data);
    preorder(root->left);
    preorder(root->right);
}

//pre order travel; no recursive version
void preorder1(Node* root){
    if(root==NULL) return;
    stack<Node*> mys;
    mys.push(root);
    while(!mys.empty()){
        Node* node = mys.top();
        mys.pop();
        printf("%d ",node->data);
        if(node->right!=NULL) mys.push(node->right);
        if(node->left!=NULL) mys.push(node->left);
    }
}

//in order travel
void inorder(Node* root){
    if(root==NULL) return;
    inorder(root->left);
    printf("%d ",root->data);
    inorder(root->right);
}

//in order travel; no recursive version
void inorder1(Node* root){
    if(root==NULL) return;
    stack<Node*> mys;
    while(root!=NULL || !mys.empty()){
        while(root!=NULL){
            mys.push(root);
            root = root->left;
        }
        if(!mys.empty()){
            Node* temp = mys.top();
            printf("%d ",temp->data);
            mys.pop();
            root = temp->right;
        }
    }
}

//post order travel
void postorder(Node* root){
    if(root==NULL) return;
    postorder(root->left);
    postorder(root->right);
    printf("%d ",root->data);
}

//post order travel; no recursive version
void postorder1(Node* root){
    if(root==NULL) return;
    stack<Node*> mys;
    Node* cur;
    Node* pre=NULL;
    mys.push(root);
    while(!mys.empty()){
        cur = mys.top();
        if(cur->left==NULL && cur->right==NULL ||
            (pre!=NULL)&&(pre==cur->left||pre==cur->right)){
            printf("%d ",cur->data);
            mys.pop();
            pre = cur;
        }else{
            if(cur->right!=NULL) mys.push(cur->right);
            if(cur->left!=NULL) mys.push(cur->left);
        }
    }
}

//level order travel
void levelorder(Node* root){
    if(root==NULL) return;
    queue<Node*> myq;
    myq.push(root);
    while(!myq.empty()){
        Node* node = myq.front();
        printf("%d ",node->data);
        myq.pop();

        if(node->left!=NULL) myq.push(node->left);
        if(node->right!=NULL) myq.push(node->right);
    }
}

//post-order to relese this tree
void destroy(Node* root){
    if(root==NULL) return;
    destroy(root->left);
    destroy(root->right);
    delete root;
}

int main(){
    Node* root = new Node(1);
    Node* n1 = new Node(2);
    Node* n2 = new Node(3);
    Node* n3 = new Node(4);
    Node* n4 = new Node(5);
    Node* n5 = new Node(6);
    Node* n6 = new Node(7);
    Node* n7 = new Node(8);
    root->left = n1;
    root->right = n2;
    n1->left = n3;
    n1->right = n4;
    n2->left = n5;
    n2->right = n6;
    n3->left = n7;
    
    preorder(root);
    puts("");
    preorder1(root);
    puts("");
    
    inorder(root);
    puts("");
    inorder1(root);
    puts("");
    
    postorder(root);
    puts("");
    postorder1(root);
    puts("");
    
    levelorder(root);
    puts("");

    destroy(root);
    return 0;
}