【算法】二叉树非递归遍历

本节给出二叉树非递归遍历算法；

前序遍历

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution
{
public:
  vector<int> preorderTraversal(TreeNode *root)
  {
    vector<int> preOrderSequence;
    preOrderSequence.reserve(10);

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

    TreeNode *node;
    while (!stack.empty())
      {
        node = stack.top();
        stack.pop();

        while (node)
          {
            preOrderSequence.push_back(node->val);
            if (node->right)
              {
                stack.push(node->right);
              }

            node = node->left;
          }
      }

    return preOrderSequence;
  }
};

说明几点

（1）首先遍历本身的节点，然后遍历左子树，此时若该节点有右子树，那么也要将其压入栈中；

中序遍历

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution
{
public:
  vector<int> inorderTraversal(TreeNode *root)
  {
    vector<int> inorderSequence;
    inorderSequence.reserve(10);
    
    stack<TreeNode *> stack;

    TreeNode *node = root;
    while (node)
      {
        stack.push(node);
        node = node->left;
      }

    while (!stack.empty())
      {
        TreeNode * cur = stack.top();
        stack.pop();

        inorderSequence.push_back(cur->val);

        if (cur->right)
          {
            stack.push(cur->right);

            TreeNode* temp = cur->right->left;
            while (temp)
              {
                stack.push(temp);
                temp = temp->left;
              }
          }
      }

    return inorderSequence;
  }
};

说明几点

（1）中序遍历，对每一个节点都要检查其右子树（将要遍历），也要依次将其右子树的左边序列压入栈中；

后序遍历

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution
{
public:
  vector<int> postorderTraversal(TreeNode *root)
  {
    vector<int> postOrderSequence;
    postOrderSequence.reserve(10);

    stack<TreeNode *> stack;
    TreeNode * node = root;
    while (node)
      {
        stack.push(node);
        node = node->left;
      }

    set<TreeNode *> access;
    while (!stack.empty())
      {
        TreeNode *node = stack.top();

        set<TreeNode *>::iterator iter = access.find(node);
        if (iter == access.end())
          {
            access.insert(node);

            TreeNode *child = node->right;
            while (child)
              {
                stack.push(child);
                child = child->left;
              }

          }
        else
          {
            postOrderSequence.push_back(node->val);
            access.erase(iter);
            stack.pop();
          }
      }

    return postOrderSequence;
  }
};

说明几点
（1）后序遍历，每一个节点需要两次入栈；

层序遍历

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution
{
public:
  vector<vector<int> > levelOrder(TreeNode *root)
  {
    vector<vector<int> > results;

    if (!root)
      return results;

    queue<TreeNode*> nodes;
    nodes.push(root);

    vector<int> result;
    while (!nodes.empty())
      {
        int size = nodes.size();
        int count = 1;
        result.clear();
        while (count++ <= size)
          {
            TreeNode* temp = nodes.front();
            nodes.pop();

            result.push_back(temp->val);

            if (temp->left)
              nodes.push(temp->left);

            if (temp->right)
              nodes.push(temp->right);
          }

        results.push_back(result);
      }

    return results;
  }
};