二叉树的遍历

二叉树的遍历

二叉树是一种常用并且重要的数据结构，其是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树中一个比较常用的操作是遍历二叉树。

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。
遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。
———-[百度百科]

本文中使用的二叉树的节点结构如下：

struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };

---

二叉树的遍历根据访问节点的顺序不同分为三种：前序遍历（Preorder），中序遍历(Inorder)，后序遍历(PostOrder)。代码可以分成递归和非递归两种实现方式。

前序遍历

前序遍历是对于一个节点，我们先访问该节点，再访问该节点的左子树，最后访问该节点的右子树。
递归的实现方式如下：

void preorder(TreeNode *root, vector<int> &result)
    {
        if(root)
        {
            result.push_back(root->val);
            if(root->left) 
                preorder(root->left,result);//递归左子树
            if(root->right)
                preorder(root->right,result);//递归右子树
        }
    }

    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> result;
        preorder(root,result);
        return result;
    }

非递归实现方式如下：

vector<int> preorderTraversal(TreeNode *root) {
        vector<int> result; 
        if(!root) return result;

        stack<TreeNode*> s;
        s.push(root);

        while(!s.empty())
        {
            TreeNode* n = s.top(); 
            result.push_back(n->val);
            s.pop();
            //根据栈后进先出的特点先存入右子树，再存入左子树，确保                                了每次都先访问节点的左子树，然后是右子树
            if(n->right) s.push(n->right);
            if(n->left) s.push(n->left);

        }

        return result;
    }

非递归的核心是利用栈，先将根节点放入栈中，然后不断对栈中元素访问，每出栈一个元素，就可看成访问了该元素，然后根据栈后进先出的特点先存入节点右子树，再存入左子树，确保了每次都先访问节点的左子树，然后是右子树。

中序遍历

中序遍历是对于一个节点，我们先访问该节点的左子树，再访问该节点，最后访问该节点的右子树。
递归的实现方式

void inorder(TreeNode *root,vector<int> &ret)
    {
        if(root)
        {
            inorder(root->left,ret);
            ret.push_back(root->val);
            inorder(root->right,ret);
        }
    }
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> ret;
        inorder(root,ret);
        return ret;
    }

非递归的实现方式

vector<int> inorderTraversal(TreeNode *root) {
        vector<int> ret;
        stack<TreeNode *> s;
        TreeNode *p = root;      
        do
        {
            while (p != NULL)
            {
                s.push(p);
                p = p->left;
            }

            if (!s.empty())
            {
                p = s.top();
                s.pop();

                ret.push_back(p->val);

                p = p->right;
            }
        } while (!s.empty() || p != NULL);

        return ret; 
    }

非递归的实现也是利用了栈，当遇到一个节点时，先遍历到其左子树的最左边，途中不断地入栈，则每当出栈一个元素时，其左子树已经完全被遍历，然后访问该节点，之后指向该节点的右子树。

后序遍历

后序遍历是对于一个节点，我们先访问该节点的左子树，再访问该节点的右子树，最后访问该节点。
递归方式：

void postorder(TreeNode *root,vector<int> &result)
    {
        if(root)
        {
            postorder(root->left,result);
            postorder(root->right,result);
            result.push_back(root->val);
        }
    }

    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> result;
        postorder(root,result);
        return result;
    }

非递归方式：

vector<int> postorderTraversal(TreeNode *root) {
        vector<int> result;
        if(!root) return result;

        stack<TreeNode*> stack;
        stack.push(root);

        while(!stack.empty())
        {
            TreeNode* node = stack.top();
            result.push_back(node->val);
            stack.pop();

            if(node->left) stack.push(node->left);
            if(node->right) stack.push(node->right);
        }
        reverse(result.begin(), result.end());

        return result;
    }

后序遍历要是直接用非递归的方式实现会有点麻烦，我们可以按照先节点，再右子树，再左子树的顺便遍历，而这个顺序的实现方式我们可以参照先序遍历，只不过是左右子树的入栈顺序变一下，之后再将遍历的节点逆序即可。

层次遍历

层次遍历是一层层遍历的树，如下图：

该树的层次遍历结果是：3,9,20,15,7.
递归实现方式，也可以看成是DFS(深度优先搜索)：

void solve(int dep,TreeNode *root,vector<vector<int>> &result)
    {
        if(!root)
            return;
        if(dep>=result.size())
        {
            vector<int> res;
            res.push_back(root->val);
            result.push_back(res);
        }else{
            result[dep].push_back(root->val);
        }

        solve(dep+1,root->left,result);
        solve(dep+1,root->right,result);
    }

    vector<vector<int> > levelOrder(TreeNode *root) {
        vector<vector<int>> result;  
        solve(0,root,result);    
        return result;  
    }

非递归实现方式，可看成是BFS(广度优先搜素)

 vector<vector<int> > levelOrder(TreeNode *root) {
        vector<vector<int>> result;  
        if(root == NULL) return result;  

        queue<TreeNode*> q;  
        queue<int> queue_level;  
        q.push(root);   
        queue_level.push(0);  

        vector<int> elem;  
        result.push_back(elem);  

        while(q.size() > 0){  
            TreeNode* x = q.front();  
            q.pop();  
            int l = queue_level.front();  
            queue_level.pop();  

            if(l > (result.size()-1) ){  //需要新增一个层级
                vector<int> elem;  
                result.push_back(elem);  
            }  
            result[l].push_back(x->val);  
             //将左右节点加入到队列中，层级需要加1 
            if(x->left != NULL){  
                q.push(x->left);  
                queue_level.push(l+1);  
            }  

            if(x->right != NULL){  
                q.push(x->right);  
                queue_level.push(l+1);  
            }  

        }  

        return result;  
    }

广度优先搜素需要维护两个队列，一个用来保存节点，一个来保存节点的层级，两者在两个队列里一一对应，根节点是0层。每次取两个队列的头元素，判断层级和结果集result的大小，做出对应的操作(和递归一样的操作)。之后将节点的左右节点加入到队列中，直到遍历所有节点。