二叉数的遍历

二叉树的三种遍历（递归和非递归）

1. 后续遍历
   (1)递归实现+非递归实现

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode{
    int value;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int _value):value(_value),left(NULL),right(NULL){}
};

//递归实现代码，很简洁
void PosterOrderRecursion(TreeNode *root, vector<int> &sequence){
    if(root == NULL){
        return;
    }
    else{
        PosterOrder(root->left,sequence);
        PosterOrder(root->right,sequence);
        sequence.push_back(root->value);
    }
}

//非递归实现，依赖栈，注意节点的遍历次数
void PosterOrderNonRecursion(TreeNode *root , vector<int> &sequence){
    sequence.clear();
    stack< pair<TreeNode *, int> > s;
    s.push(make_pair(root,0));
    while(!s.empty()){
        TreeNode *cur = s.top();
        if(cur == NULL){
            s.pop();
        }
        else{
            switch(s.top().second++){
                case 0:
                    s.push(make_pair(cur->left,0));
                    break;
                case 1:
                    s.push(make_pair(cur->right,0));
                    break;
                default:
                    //第三次访问，算是要输出节点了
                    sequence.push_back(cur->value);
                    s.pop();
                    break;
            }
        }
    }
}

1. 前序遍历

//续前的节点和头文件
void PreOrderRecursion(TreeNode *root, vector<int> &sequence){
    if(root == NULL){
        return;
    }
    else{
        sequence.push_back(root->value);
        PreOrder(root->left,sequence);
        PreOrder(root->right,sequence);
    }
}

void PreOrderNonRecursion(TreeNode *root, vector<int> &sequence){
    sequence.clear();
    stack<TreeNode *> s;
    s.push(root);
    while(!s.empty){
        TreeNode *cur = s.top();
        s.pop();
        if(cur == NULL){
            continue;
        }
        else{
            sequence.push_back(cur->value);
            //注意顺序
            s.push(cur->right);
            s.push(cur->left);
        }
    }
}

1. 中序遍历

void InOrderRecursion(TreeNode *root, vector<int> &sequence){
    if(root == NULL){
        return;
    }
    else{
        PosterOrder(root->left,sequence);
        sequence.push_back(root->value);
        PosterOrder(root->right,sequence);
    }
}

void InOrderNonRecursion(TreeNode *root , vector<int> &sequence){
    sequence.clear();
    stack< pair<TreeNode *, int> > s;
    s.push(make_pair(root,0));
    while(!s.empty()){
        TreeNode *cur = s.top();
        if(cur == NULL){
            s.pop();
        }
        else{
            switch(s.top().second++){
                case 0:
                    s.push(make_pair(cur->left,0));
                    break;
                case 1:
                    sequence.push_back(cur->value);
                    s.pop();
                    s.push(make_pair(cur->right,0));
                    break;
            }
        }
    }
}