Flatten Binary Tree to Linked List

                            Solution in C :

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

typedef struct TreeNode node;

typedef struct child_res {
    node *root;
    node *tail;
} child_res;

child_res flatten_rec(node *root)
{
    child_res res;
    res.root = root;
    res.tail = root;
    
    if (root == NULL)
        return res;
    
    child_res left = flatten_rec(root->left);
    child_res right = flatten_rec(root->right);
    
    root->left = NULL;
    
    if (left.root) {
        res.tail->right = left.root;
        res.tail = left.tail;
    }

    if (right.root) {
        res.tail->right = right.root;
        res.tail = right.tail;
    }
    
    return res;
}

void flatten(node *root)
{
    child_res res = flatten_rec(root);
}
                        

                        Solution in C++ :

class Solution {
public:
    void flatten(TreeNode* root) {
        std::ios_base::sync_with_stdio(false);
        std::cin.tie(nullptr);
        std::cout.tie(nullptr);
        if(!root)   return;
        if(!root->left && !root->right) return;

        flatten(root->left);
        if(root->left){
            TreeNode* save= root->right;
            root->right= root->left;
            root->left= NULL;
            TreeNode* temp= root;
            while(temp->right){
                temp= temp->right;
            }
            temp->right= save;
        }
        flatten(root->right);
    }
};
                    

                        Solution in Java :

class Solution {
    TreeNode ans;

    public void flatten(TreeNode root) {
        if(root == null)
        return ;

         ans = new TreeNode(root.val);
        TreeNode ans1 = ans;
        function(root);

        root.left = null;
        root.right = ans1.right;


    }

    void function(TreeNode root){
        if(root == null)
            return ;

        ans.val = root.val;
        if(root.left !=null){
            ans.right = new TreeNode();
            ans.left = null;
            ans = ans.right;
            function(root.left);
        }
        if(root.right!=null){
            ans.right = new TreeNode();
            ans.left = null;
            ans = ans.right;
            function(root.right);
        }
    }
}
                    

                        Solution in Python : 
                            
class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        
        self.cur = None
        
        def dfs(node):
            if not node:
                return
            left, right = node.left, node.right
            node.left = None
            if self.cur:
                self.cur.right = node
                self.cur = self.cur.right
            else:
                self.cur = node
            dfs(left)
            dfs(right)
        
        dfs(root)