二叉树非递归遍历--迭代

无论是何种遍历都抓住遍历的特征

先、中、后，三种遍历方式，都是深度优先搜索，差别仅在于访问根节点的顺序。

深度优先搜索的特点：

1、使用栈。

2、存在可访问节点时，向下延伸。

3、无可访问节点时，回退至上级可访问节点。

二叉树先、中、后遍历中DFS思想的体现：

1、使用栈。

2、左子树存在，向左子树迭代。

3、左子树不存在，移向右子树，回2。

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> preorderTraversal(TreeNode *root) {
        stack<TreeNode *> pStack;
        while (root || !pStack.empty()) {
            while (root) {
                result.push_back(root->val);
                pStack.push(root);
                root = root->left;
            }
            
            if (!pStack.empty()) { // 这里栈不会为空，所以可以去掉
                root = pStack.top();
                pStack.pop();
                root = root->right;
            }
        }
        return result;
    }
private:
    vector<int> result;
};

2、中序

特征：一直向左，不访问，入栈，回退访问，向右，再一直向左

/**
 * 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) {
        stack<TreeNode *> pStack;
        while (root || !pStack.empty()) {
            while (root) {
                pStack.push(root);
                root = root->left;
            }
            
            if (!pStack.empty()) {
                root = pStack.top();
                pStack.pop();
                result.push_back(root->val);
                root = root->right;
            }
        }
        return result;
    }
private:
    vector<int> result;
};

3、后序

特征：叶节点直接访问；非叶节点，子树必须已访问，上一个被访问的必然是子节点

/**
 * 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) {
        if (root == NULL) {
            return result;
        }
        stack<TreeNode *> s;
        TreeNode *pre = NULL;
        s.push(root);
        while (!s.empty()) {
            root = s.top();
            if (root->left == NULL && root->right == NULL) {
                result.push_back(root->val);
                pre = root;
                s.pop();
            } else if (root->right != NULL && pre == root->right) {
                result.push_back(root->val);
                pre = root;
                s.pop();
            } else if (root->left != NULL && pre == root->left) {
                result.push_back(root->val);
                pre = root;
                s.pop();
            } else {
                if (root->right && pre != root->right) {
                    s.push(root->right);
                }
                if (root->left && pre != root->left) {
                    s.push(root->left);
                }
            }
        }
        return result;
    }
    
private:
    vector<int> result;
};

考虑到节点如果有左子树，则必然先背访问，那么需要考虑的是右子树如果存在，有没有被访问呢？

/**
 * 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) {
        if (root == NULL) {
            return result;
        }
        stack<TreeNode *> s;
        TreeNode *pre = NULL;
        TreeNode *cur = root;
        while (cur || !s.empty()) {
            while (cur) {
                s.push(cur);
                cur = cur->left;
            } // 一直向左子树方向探索
            cur = s.top();
            if (cur->right == NULL || pre == cur->right) {
                result.push_back(cur->val);
                pre = cur;
                s.pop();
                cur = NULL;
            } else {
                cur = cur->right;
            }
        }
        return result;
    }
    
private:
    vector<int> result;
};

优化

迭代条件是

1、节点不空，此时栈可能为空，进入迭代会将节点入栈；

2、或者栈不空

因此在任何遍历出栈的时候，都可以保证栈是不空的，在出栈前也就没有必要判断栈是否为空。

优化的先序

/**
 * 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) {
        stack<TreeNode *> s;
        TreeNode *cur = root;
        while (cur || !s.empty()) {
            while (cur) {
                re.push_back(cur->val);
                s.push(cur);
                cur = cur->left;
            }
            cur = s.top();
            cur = cur->right;
            s.pop();
        }
        return re;
    }

private:
    vector<int> re;
};

优化的中序

/**
 * 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) {
        stack<TreeNode *> s;
        while (root || !s.empty()) {
            while (root) {
                s.push(root);
                root = root->left;
            }
            
            root = s.top();
            s.pop();
            re.push_back(root->val);
            root = root->right;
        }
        return re;
    }
private:
    vector<int> re;
};

优化的后序

/**
 * 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) {
        stack<TreeNode *> s;
        TreeNode *pre = NULL, *cur = root;
        while (cur || !s.empty()) {
            while (cur) {
                s.push(cur);
                cur = cur->left;
            }
            cur = s.top();
            if (cur->right && pre != cur->right) {
                cur = cur->right;
            } else {
                re.push_back(cur->val);
                pre = cur;
                s.pop();
                cur = NULL;
            }
        }
        return re;
    }
    
private:
    vector<int> re;
};