leetcode 94二叉树的中序遍历

递归算法C++代码：

/**
 * Definition for a binary tree node.
 * 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> tra;
        Morder(root,tra);
        return tra;
    }
    void Morder(TreeNode* root,vector<int> &tra){
        if(root==NULL) return;
        if(root->left)
            Morder(root->left,tra);
        tra.push_back(root->val);
        if(root->right)
            Morder(root->right,tra);
    }
};

 非递归方法（迭代）：通过stack容器

C++代码：O(n)空间复杂度,O(n)时间复杂度

 自己写的，实际上为将递归方法代码用stack具体化，需要注意的是加上了回溯与向下递归的判别；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
/**
迭代法：具象描述递归执行过程
1）检查当前p是否为NULL,如果非NULL,当前节点入栈，只要当前节点有左子节点，左子节点入栈；
2）1之后，取栈顶元素p，由于1的操作，p没有左子节点，那么访问当前节点的值，且p出栈；
3）接下来访问右节点，p=p->right,如果右子节点存在，那么入栈，循环结束；                  
**/
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root==NULL) return {};
        vector<int>res;
        stack<TreeNode*>s;
        TreeNode*p=root;
        s.push(p);
        while(!s.empty()){
            while(p&&p->left){
                p=p->left;s.push(p);
            }
            
            p=s.top();
            res.push_back(p->val);s.pop();
            
            //此处先令p=p->right,p可用作第一个while判断是向下递归还是回溯，如果递归过程p为非空，如果为NULl则代表回溯，那么下一轮不用向左递归；
            p=p->right;
            if(p) s.push(p);
        }
        return res;
    }
};

 

 

别人的代码：

/**
 * Definition for a binary tree node.
 * 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> res;
        stack<TreeNode*> st;
        TreeNode* T=root;
        while(T||!st.empty()){
            //将T的所有左孩子入栈
            while(T){
                st.push(T);
                T=T->left;
            }
            //访问T的元素，然后转到T的右孩子
            if(!st.empty()){
                T=st.top();
                st.pop();
                res.push_back(T->val);
                T=T->right;
            }
        }
        return res;
    }
};

 方法三：Morris Traversal

由于需要用到Thread Binary  Tree（线索二叉树），参考 透彻理解线索二叉树 彻底理解线索二叉树 

Morris Traversal方法遍历二叉树（非递归，不用栈，O(1)空间） 

对于n个节点的二叉树，左右孩子指针为2n个，利用的指针为n-1个，没有利用的指针为n+1个；利用空链域存储前驱和后继：

 

记ptr指向二叉链表中的一个结点，以下是建立线索的规则：

    （1）如果ptr->lchild为空，则存放指向中序遍历序列中该结点的前驱结点。这个结点称为ptr的中序前驱；

    （2）如果ptr->rchild为空，则存放指向中序遍历序列中该结点的后继结点。这个结点称为ptr的中序后继；

当然，Morris遍历只用到了线索二叉树的思想和部分操作，线索二叉树的更细节的东西此处不赘述。对于本题，实际上只用到了对叶节点的右指针的线索化，以及通过线索化的指针进行回溯。主要有以下两点：

#1 对所有叶节点的右指针的线索化，令其指向中序遍历的后继节点；

#2 通过线索化的节点，访问中序遍历的后继节点，并恢复被线索化的节点；

参考：二叉树的遍历：先序中序后序遍历的递归与非递归实现及层序遍历

C++代码如下：O(1)空间复杂度,O(n)时间复杂度

/**
 * Definition for a binary tree node.
 * 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) {
        //Morris Traversal：右线索化+回溯
        vector<int> res;
        if(!root) return res;
        TreeNode *p=root;
        
        while(p){
            //定义两个节点指针变量p和p的左孩子pLeft
          TreeNode *pLeft=p->left;
            if(pLeft){
                //访问p的左孩子的最右子孩子（即pLeft右孩子的右孩子的右孩子...）
                //线索化之前pLeft的最右子孩子的right指针指向NULL,
                //线索化之后pLeft的最右子孩子的right指向中序遍历中该节点的后继节点p
                //所以循环终止条件为pLeft->right==NULL 或 pLeft->right==p
                while(pLeft->right && pLeft->right!=p){
                    pLeft=pLeft->right;
                }
                //此时pLeft代表p的左孩子的最右子孩子
                //pLeft->right==NULL代表没有被线索化，进行线索化然后访问p的左孩子
                if(pLeft->right==NULL){
                    pLeft->right=p;
                    p=p->left;
                    continue;
                }
                //pLeft->right!=NULL代表已经被线索化，此时已经回溯到原来的节点p(第2次访问)，所以要恢复被线索化的pLeft的最右子孩子
                else{
                    pLeft->right=NULL;
                }
            }
            res.push_back(p->val);
            p=p->right;//访问右孩子（对非叶节点），回溯到中序遍历的后续节点（对叶节点）；
            //因为线索化的操作最终是对所有的叶节点进行的，所以上述语句实际有访问右孩子和回溯两个功能；
        }
        return res;
    }
};