二叉树的Morris遍历

Morris遍历的核心思想就是去，找到当前节点的左节点的最右节点，然后判断其右节点是否为空，如果为空，则将其右节点指向当前节点并让当前节点往左走；如果其右节点指向当前节点则置为空，并让当前节点往右走。如此循环直到走到最右节点结束遍历过程。

1、遍历过程如下：

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        while(root){
            TreeNode* ll=root->left;
            if(ll){
                while(ll->right&&ll->right!=root){
                    ll=ll->right;
                }
                if(ll->right){
                    TreeNode* temp=root->left;
                    ll->right=nullptr;
                }else{
                    //cout<val<
                    ll->right=root;
                    root=root->left;
                    continue;
                }
            }//else cout<val<
            root=root->right;
        }
        return nullptr;  
    }
};

2、中序遍历

中序遍历的核心是走一次的节点，走一次的时候直接打印，走两次的节点，第二次打印

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        while(root){
            TreeNode* ll=root->left;
            if(ll){
                while(ll->right&&ll->right!=root){
                    ll=ll->right;
                }
                if(ll->right){
                    TreeNode* temp=root->left;
                    ll->right=nullptr;
                }else{
                    //cout<val<
                    ll->right=root;
                    root=root->left;
                    continue;
                }
            }//else cout<val<
            cout<val<
            root=root->right;
        }
        return nullptr;  
    }
};

2、前序遍历

前序遍历的核心第一次走到就遍历

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        while(root){
            TreeNode* ll=root->left;
            if(ll){
                while(ll->right&&ll->right!=root){
                    ll=ll->right;
                }
                if(ll->right){
                    TreeNode* temp=root->left;
                    ll->right=nullptr;
                }else{
                    cout<val<
                    ll->right=root;
                    root=root->left;
                    continue;
                }
            }else cout<val<
            root=root->right;
        }
        return nullptr;  
    }
};

2、后序遍历

后序遍历的核心最后一次走的时候，对改节点的左子树的最右层进行逆序遍历（通过链表的反转实现，但是遍历完需要在转回去）

/**
 * 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:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        TreeNode* ans=root;
        while(root){
            TreeNode* ll=root->left;
            if(ll){
                while(ll->right&&ll->right!=root){
                    ll=ll->right;
                }
                if(ll->right){
                    ll->right=nullptr;
                    TreeNode* temp=root->left;
                    temp= reverse_list(temp);
                    TreeNode* temp1=temp;
                    while(temp1){
                        cout<val<
                        temp1=temp1->right;
                    }
                    temp=reverse_list(temp);
                    
                }else{
                    ll->right=root;
                    root=root->left;
                    continue;
                }
            }
            root=root->right;
        }
        TreeNode*temp=reverse_list(ans);
        TreeNode* temp1=temp;
        while(temp1){
            cout<val<
            temp1=temp1->right;
        }
        ans=reverse_list(temp);
        return nullptr;  
    }
    TreeNode* reverse_list(TreeNode* node){
        TreeNode* pre=nullptr;
        while(node){
            TreeNode* temp=node;
            node=node->right;
            temp->right=pre;
            pre=temp;
        }
        return pre;
    }
};