LeetCode_114 二叉树展开为链表

题目描述：

思路：

由题目可以将解题过程分为以下几个步骤：
1.将当前节点的右子树连接到当前节点左子树的最右边节点的右子树上
2.将当前节点的左子树连接到右子树上，并将左子树置空
3.将当前节点的右子树作为新的当前节点，重复上述过程

查找最右侧节点未必需要写递归，写循环也可以，所以我得出做树的问题，有时候也可以尝试使用循环来解决

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode* root) {
        if(root==nullptr)
            return ;
        while(root){
            if(root->left==nullptr)
                root=root->right;
            else{
                TreeNode* pre=root->left;
                //循环查找最右子节点
                while(pre->right){
                    pre=pre->right;
                }
                pre->right=root->right;
                root->right=root->left;
                root->left=nullptr;
                root=root->right;
            }
        }
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	//递归查找最右子节点，思路其实一样
    TreeNode* findr(TreeNode* root){
        if(root->right==nullptr)
            return root;
        return findr(root->right);
    }

    void flatten(TreeNode* root) {
        if(root==nullptr)
            return ;
        while(root){
            if(root->left==nullptr)
                root=root->right;
            else{
                TreeNode* pre=findr(root->left);
                pre->right=root->right;
                root->right=root->left;
                root->left=nullptr;
                root=root->right;
            }
        }
    }
};

思路：

题目很明显是按照先序遍历去遍历的二叉树，但如果按照先序遍历，将当前节点的右子树指向左子树，则右子树会丢失，但是可以逆序思考(跟先序遍历正好相反的顺序遍历)，这样右子树就不会丢失了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void posttrave(TreeNode* &root,TreeNode* &pre){
        if(root==nullptr)
            return ;
        posttrave(root->right,pre);
        posttrave(root->left,pre);
        root->right=pre;
        root->left=nullptr;
        pre=root;
    }

    void flatten(TreeNode* root) {
        if(root==nullptr)
            return ;
        TreeNode* pre=nullptr;
        posttrave(root,pre);
    }
};

思路：

既然右子树会丢失，那就申请一个栈来存放树节点，这样右子树就不会丢失了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode* root) {
        if(root==nullptr)
            return ;
        stack<TreeNode*> sv;
        sv.push(root);
        TreeNode* pre=nullptr;
        while(!sv.empty()){
            TreeNode* now=sv.top();
            sv.pop();
            if(pre!=nullptr){
                pre->right=now;
                pre->left=nullptr;
            }
            if(now->right)
                sv.push(now->right);
            if(now->left)
                sv.push(now->left);
            pre=now;
        }
    }
};