Morris遍历二叉树

#include<iostream>
#include<list>
using namespace std;

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

class Solution
{
public:
    void preMorris(TreeNode* root)
    {
        TreeNode* cur=root;
        while(cur)
        {
            if(!cur->left)
            {
                cout<<cur->value<<' ';
                cur=cur->right;
            }
            else
            {
                TreeNode* node=cur->left;
                while(node->right&&node->right!=cur)
                {
                    node=node->right;
                }
                if(!node->right)
                {
                    cout<<cur->value<<' ';
                    node->right=cur;
                    cur=cur->left;
                }
                else
                {
                    node->right==NULL;
                    cur=cur->right;
                }
            }
        }
    }
    void inorderMorris(TreeNode* root)
    {
        TreeNode* cur=root;
        while(cur)
        {
            if(!cur->left)
            {
                cout<<cur->value<<' ';
                cur=cur->right;
            }
            else
            {
                    TreeNode* node=cur->left;
                    while(node->right&&node->right!=cur)
                    {
                        node=node->right;
                    }
                    if(!node->right)
                    {
                        node->right=cur;
                        cur=cur->left;
                    }
                    else
                    {
                        cout<<cur->value<<' ';
                        cur=cur->right;
                        node->right==NULL;
                    }
                }
            }
        }
        void postMorris(TreeNode* root)
        {
            TreeNode* dump=new TreeNode(-1);
            dump->left=root;
            TreeNode* cur=dump;
            list<TreeNode*>result;
            while(cur)
            {
                if(!cur->left)
                {
                    cur=cur->right;
                }
                else
                {
                    TreeNode* node=cur->left;
                    while(node->right&&node->right!=cur)
                    {
                        node=node->right;
                    }
                    if(!node->right)
                    {
                        node->right=cur;
                        cur=cur->left;
                    }
                    else
                    {   
                        node->right=NULL;
                        TreeNode* temp=cur->left;
                        int count=0;
                        while(temp)
                        {
                            auto it=result.end();
                            int i=0;
                            while(i<count)
                            {
                                it--;
                                i++;
                            }
                            result.insert(it,temp);
                            temp=temp->right;       
                            count++;
                        }
                        cur=cur->right; 
                    }
                }       
            }
            display(result);
        }
        void display(list<TreeNode*>result)
        {
            for(auto i:result)
            {
                cout<<i->value<<' ';
            }
            cout<<endl;
        }
};

void main()
{
    TreeNode* node1=new TreeNode(1);
    TreeNode* node2=new TreeNode(2);
    TreeNode* node3=new TreeNode(3);
    TreeNode* node4=new TreeNode(4);
    TreeNode* node5=new TreeNode(5);
    TreeNode* node6=new TreeNode(6);
    TreeNode* node7=new TreeNode(7);
    node1->left=node2;
    node1->right=node3;
    node2->left=node4;
    node2->right=node5;
    node3->left=node6;
    node3->right=node7;
    Solution solution;
    //solution.preMorris(node1); //Morris 前序遍历方法
    //solution.inorderMorris(node1);    //Morris中序遍历方法
    solution.postMorris(node1); //Morris后续遍历方法

}