二叉树的遍历

二叉树的遍历

二叉树的遍历主要分为三种：
　　1、前序遍历（根–>左–>右）
　　2、中序遍历（左–>根–>右）
　　3、后序遍历（左–>右–>根）
　　其中对于二叉排序树而言，中序遍历的结果是按序增大的
　　以递归的方式来实现三种遍历非常简单，如果要以非递归的方式实现遍历，那么一般需要栈作为辅助结构

1、前序遍历（根–>左–>右）

1.1递归

void preOrder(TreeNode *root){
        if(root==NULL)  return; 

        cout<<root->val<<endl;
        preOrder(root->left);
        preOrder(root->right);
}

1.2非递归

void preOrder(TreeNode *root){
        if(root==NULL)  return;
        stack<TreeNode *> s;
        s.push(root);
        while(!s.empty()){
                TreeNode *t=s.top();
                s.pop();
                cout<<t->val<<endl;
                if(t->right)    s.push(t->right);
                if(t->left)     s.push(t->left);
        }
}

2、中序遍历（左–>根–>右）

2.1递归

void inOrder(TreeNode *root){
        if(root==NULL)  return;

        inOrder(root->left);
        cout<<root->val<<endl;
        inOrder(root->right);
}

2.2非递归

void inOrder(TreeNode *root){
        stack<TreeNode *> s;
        TreeNode *p=root;
        while(p||!s.empty()){
                while(p){
                    s.push(p);
                    p=p->left;
                }
                if(!s.empty()){
                    p=s.top();
                    s.pop();
                    cout<<p->val<<endl;
                    p=p->right;
        }
}

3、后序遍历（左–>右–>根）

3.1递归

void postOrder(TreeNode *root){
        if(root==NULL)  return;

        postOrder(root->left);
        cout<<root->val<<endl;
        postOrder(root->right);
}

3.2非递归

void postOrder(TreeNode *root){
        stack<TreeNode *> s;
        TreeNode *p=root;
        TreeNode *prev=NULL;
        while(p||!s.empty()){
            while(p){
                s.push(p);
                p=p->left;
            }
            p=s.top();
            if(p->right==NULL||p->right==prev){
                cout<<p->val<<endl;
                s.pop();
                prev=p;
                p=NULL;
            }else{
                p=p->right;
            }
        }
}

4、树的层次遍历

4.1层次遍历，每一层按序输出
以一个队列作为辅助结构，在每一层的末尾插入一个NULL指针来分隔每一层

vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>    q;
        vector<vector<int> > ret;
        if(root==NULL)  return ret;
        q.push(root);
        q.push(NULL);
        TreeNode *p=NULL;
        vector<int> tmp;
        while(!q.empty()){
            p=q.front();
            q.pop();
            if(p==NULL&&q.empty()){
                if(!tmp.empty())    ret.push_back(tmp);
                return ret;
            }else if(p==NULL){
                ret.push_back(tmp);
                tmp.clear();
                q.push(NULL);
            }else{
                tmp.push_back(p->val);
                if(p->left) q.push(p->left);
                if(p->right)    q.push(p->right);
            } 
        }
        return ret;
    }

4.2层次遍历，以zig-zag的形式输出
以两个栈作为辅助结构

vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int> > ret;
        if(root==NULL)  return ret;
        stack<TreeNode *> s[2];
        int i=0;
        s[i].push(root);
        vector<int> tmp;
        TreeNode *p=NULL;
        while(!s[i].empty()){
            while(!s[i].empty()){
                p=s[i].top();
                s[i].pop();
                tmp.push_back(p->val);
                if(!i){
                    if(p->left) s[!i].push(p->left);
                    if(p->right)    s[!i].push(p->right);
                }else{
                    if(p->right)    s[!i].push(p->right);
                    if(p->left) s[!i].push(p->left);
                }
            }
            if(tmp.size()){
                ret.push_back(tmp);
                tmp.clear();
            }
            i=!i;

        }
        return ret;
    }