二叉树的先序、中序、后序、分层遍历

先序遍历（DLR）二叉树的操作为：
若二叉树为空，则空操作；否则：
（1）访问根节点
（2）先序遍历左子树
（3）先序遍历右子树

中序遍历（LDR）二叉树的操作为：
若二叉树为空，则空操作；否则：
（1）中序遍历左子树
（2）访问根节点
（3）中序遍历右子树

后序遍历（LRD）二叉树的操作为：
若二叉树为空，则空操作；否则：
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根节点

分层遍历二叉树的操作为：
若二叉树为空，则空操作；否则按层访问每一个节点

假设一个二叉树如下图所示：

先序遍历：1 2 4 3
中序遍历：2 4 1 3
后序遍历：4 2 3 1
分层：1 2 3 4

C++代码实现如下：
节点结构定义如下：

struct Node{
    int val;
    struct Node *left;
    struct Node *right;
};

先序遍历的算法实现为：
递归算法：

void DLR(struct Node *root)
{
    if(root!=NULL){
        printf("%d ",root->val);
        DLR(root->left);
        DLR(root->right);
    }
}

非递归算法：

void DLR_1(struct Node *root)
{
    stack<struct Node *> s;
    struct Node *p = root;
    while(p!=NULL || !s.empty()){
        while(p!=NULL){
            printf("%d ",p->val);
            s.push(p);
            p=p->left;
        }
        if(!s.empty()){
            p=s.top();
            s.pop();
            p=p->right;
        }
    }
}

中序遍历的算法实现为：
递归算法：

void LDR(struct Node *root)
{
    if(root!=NULL){
        LDR(root->left);
        printf("%d ",root->val);
        LDR(root->right);
    }
}

非递归算法：

void LDR_1(struct Node *root)
{
    stack<struct Node *> s;
    struct Node *p = root;
    while(p!=NULL || !s.empty()){
        while(p!=NULL){
            s.push(p);
            p = p->left;
        }
        if(!s.empty()){
            p = s.top();
            printf("%d ",p->val);
            s.pop();
            p = p->right;
        }
    }
}

后序遍历的算法实现为：
递归算法：

void LRD(struct Node *root)
{
    if(root!=NULL){
        LRD(root->left);
        LRD(root->right);
        printf("%d ",root->val);
    }
}

非递归算法：

void LRD_1(struct Node *root)
{
    stack<struct Node *> s;
    struct Node *pre = NULL;
    struct Node *cur = NULL;
    s.push(root);
    while(!s.empty()){
        cur = s.top();
        if((cur->left==NULL && cur->right==NULL) || (pre!=NULL && (pre==cur->left || pre==cur->right))){
            printf("%d ",cur->val);
            s.pop();
            pre = cur;
        }
        else{
            if(cur->right!=NULL){
                s.push(cur->right);
            }
            if(cur->left!=NULL){
                s.push(cur->left);
            }
        }
    }
}

分层遍历算法实现如下：

void PrintFromTopToBottom(Node* root)
{
    if(root == NULL){
        return;
    }
    queue<Node*> q;
    q.push(root);
    while(!q.empty()){
        Node* temp = q.front();
        cout << temp->value << " ";
        q.pop();
        if(temp->left != NULL){
            q.push(temp->left);
        }
        if(temp->right != NULL){
            q.push(temp->right);
        }
    }
}