剑指offer 树的基本操作：四种遍历方式

前序遍历 递归版

编程思想

即借助系统栈，效率较低。二叉树的前序遍历规则:1. 访问根结点； 2. 遍历左子树； 3. 遍历右子树

编程实现

//树的定义
struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
private:
    void rec(TreeNode* root,vector<int> &ret){
        if(root != nullptr){
            ret.push_back(root->val);
            rec(root->left,ret);
            rec(root->right,ret);
        }
    }
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        rec(root,ret);
        return ret;
    }
};

编程总结

常规方法，注意向量要用引用。

---

前序遍历 迭代版

编程思想

使用了一个辅助结点p，这种写法其实可以看作是一个模版，对应的还有中序和后序的模版写法，形式很统一，方便于记忆。
辅助结点p初始化为根结点，while循环的条件是栈不为空或者辅助结点p不为空，在循环中首先判断如果辅助结点p存在，那么先将p加入栈中，然后将p的结点值加入结果res中，此时p指向其左子结点。否则如果p不存在的话，表明没有左子结点，我们取出栈顶结点，将p指向栈顶结点的右子结点。

编程实现

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (!s.empty() || p) {
            if (p) {
                s.push(p);
                res.push_back(p->val);
                p = p->left;
            }
            else {
                TreeNode *t = s.top();
                s.pop();
                p = t->right;
            }
        }
        return res;
    }
};    

题目总结

在掌握规律的前提下，使用模板记忆。

---

中序遍历 递归版

编程思想

即借助系统栈，效率较低。二叉树的前序遍历规则:1. 遍历左子树； 2. 访问根结点； 3. 遍历右子树

编程实现

class Solution {
private:
    void rec(TreeNode* root,vector<int> &ret){
        if(root != NULL){
            rec(root->left,ret);
            ret.push_back(root->val);
            rec(root->right,ret);
        }
    }
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        rec(root,ret);
        return ret;
    }
};

题目总结

常规。

---

中序遍历 迭代版

编程思想

使用了一个辅助结点p，这种写法其实可以看作是一个模版，对应的还有前序和后序的模版写法，形式很统一，方便于记忆。
因为中序遍历的顺序是左-根-右，故与前序不同的是把结点值加入结果res的步骤从if中移动到了else中。
辅助结点p初始化为根结点，while循环的条件是栈不为空或者辅助结点p不为空，在循环中首先判断如果辅助结点p存在；那么先将p加入栈中，将p指向栈顶结点的左子结点。否则如果p不存在的话，表明没有左子结点，我们取出栈顶结点，然后将p的结点值加入结果res中，此时p指向其右子结点。

编程实现

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (!s.empty() || p) {
            if (p) {
                s.push(p);
                p = p->left;
            }
            else {
                TreeNode *t = s.top();
                s.pop();
                res.push_back(t->val);
                p = t->right;
            }
        }
        return res;
    }
};    

题目总结

注意与前序遍历的区别和联系，因为中序遍历的顺序是左-根-右，故与前序不同的是把结点值加入结果res的步骤从if中移动到了else中。

---

后序遍历 递归版

编程思想

即借助系统栈，效率较低。二叉树的前序遍历规则: 1. 遍历左子树；2. 遍历右子树；3. 访问根结点；

编程实现

class Solution {
private:
    void rec(TreeNode* root,vector<int> &ret){
        if(root != NULL){
            rec(root->left,ret);
            rec(root->right,ret);
            ret.push_back(root->val);
        }
    }
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        rec(root,ret);
        return ret;
    }
};

编程总结

常规。

---

后序遍历 迭代版

编程思想

使用了一个辅助结点p，这种写法其实可以看作是一个模版，对应的还有前序和中序的模版写法，形式很统一，方便于记忆。
由于后序遍历的顺序是左-右-根，而前序遍历的顺序是根-左-右，二者其实还是很相近的，我们可以先在先序遍历的方法上做些小改动，使其遍历顺序变为根-右-左，然后翻转一下，就是左-右-根了。翻转的方法，是反向加入结果res，每次都在结果res的开头加入结点值，而改变先序遍历的顺序就只要改变一下入栈顺序，先左后右，这样出栈处理的时候就是先右后左了。一定要对比前序遍历记忆！！！

拓展：当访问一个结点*p时，栈中结点恰好为*p结点的所有祖先。从栈底到栈底结点再加上*p结点，刚好构成从根节点到*p结点的一条路径。这一特性非常重要，如求根结点到某结点的路径；求两个结点的最近公共祖先；均可用这个思想。

编程实现

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (!s.empty() || p) {
            if (p) {
                s.push(p);
                res.insert(res.begin(), p->val);    //反向添加，而前序是正向添加
                p = p->right;　　//与前序对比
            }
            else {
                TreeNode *t = s.top();
                s.pop();
                p = t->left;
            }
        }
        return res;
    }
};

编程总结

拓展思想很重要！！

---

层次遍历 版本1

编程思想

进行常规层次遍历，需要借助一个队列。
先将根节点入队，然后出队，访问该根结点，如果它有左子树，则将左子树根节点入队，形成下一层；如果它有右子树，则将右子树根结点入队，形成下一层。然后出队，访问该结点，如此反复，直至队列为空。看代码比较容易懂。
补充：
queue 的基本操作有：
入队，如例：q.push(x); 将x 接到队列的末端。
出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q.front()，即最早被压入队列的元素。
访问队尾元素，如例：q.back()，即最后被压入队列的元素。
判断队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

编程实现

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {

        vector<vector<int>>v;
        queue<TreeNode*>q;
        q.push(root);  //根节点入队
        if(root == NULL)
            return v ;
        while(!q.empty()){  //队列不空
            vector<int>vv;
            queue<TreeNode*> next ;  //  建立第二个队列 用来存放下一层的结点
            while(!q.empty()){  //遍历当前层的结点  这层循环是核心 其他都是为了满足OJ输出

                TreeNode* tre = q.front() ;
                vv.push_back(tre->val);  //访问该结点,为了满足输出要求，所以有点复杂，
                q.pop();  //对头元素出队
                if(tre->left!=NULL){  //它有左子树
                    next.push(tre->left);
                }
                if(tre->right!=NULL){  //它有右子树
                    next.push(tre->right);
                }
            }
            v.push_back(vv);
            q=next;  // // 遍历完后进入下一层
        }
        return v;
    }
};

编程总结

层次遍历往往要用到队列，要对队列的基本操作熟悉，注意二维向量的生成。

---

层次遍历 版本2

编程思想

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）。

同版本一类似，只不过需要多一个栈，把每层返回的结点加入栈中，最后输出。

编程实现

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>v;
        stack<vector<int>>s;
        queue<TreeNode*>q;
        q.push(root);  //根节点入队
        if(root == NULL)
            return v ;
        while(!q.empty()){  //队列不空
            vector<int>vv;
            queue<TreeNode*> next ;  //  建立第二个队列 用来存放下一层的结点

            while(!q.empty()){  //遍历每层的结点  这层循环是核心 其他都是为了满足OJ输出

                TreeNode* tre = q.front() ;
                vv.push_back(tre->val);  //访问该结点,为了满足输出要求，所以有点复杂，
                q.pop();  //对头元素出队
                if(tre->left!=NULL){  //它有左子树
                    next.push(tre->left);
                }
                if(tre->right!=NULL){  //它有右子树
                    next.push(tre->right);
                }

            }
            s.push(vv);  //将每层结点入栈
            //v.push_back(vv);
            q=next;  // // 遍历完后进入下一层
        }
        while(!s.empty()){  //将每层结点倒序输出
            v.push_back(s.top());
            s.pop();
        }
        return v;
    }
};

编程总结

注意其他数据结构的配合使用。