Binary tree problem solving (2)

Leetcode 226._ Flip binary tree

        //  Method 1 ： Traversing the binary tree 
        public TreeNode InvertTree(TreeNode root)
        {
            //  Traversing the binary tree , Swap the children of each node 
            Traverse(root);
            return root;
        }
        //  Binary tree traversal function 
        void Traverse(TreeNode root) {
            if (root == null) return;
            //  What each node needs to do is exchange its left and right child nodes 
            TreeNode tmp = root.left;
            root.left = root.right;
            root.right = tmp;
            //  Ergodic framework , To traverse the nodes of the left and right subtrees 
            Traverse(root.left);
            Traverse(root.right);
        }

        //  Method 2 ： Recursive function decomposition problem 
        public TreeNode InvertTree(TreeNode root)
        {
            if (root == null) return root;
            //  Flip left and right subtrees 
            TreeNode left = InvertTree(root.left);
            TreeNode right = InvertTree(root.right);
            //  Swap left and right child nodes 
            root.left = right;
            root.right = left;
            //  With  root  The binary tree with roots has been flipped , return  root
            return root;
        }

Leetcode 116._ Fill in the next right node pointer for each node

        public Node Connect(Node root)
        {
            if (root == null) return null;
            Traverse(root.left,root.right);
            return root;
        }
        void Traverse(Node left,Node right)
        {
            if (left == null|| right == null) return;
            //  Put the two incoming nodes together 
            left.next = right;
            //  Connect two children of the same parent node 
            Traverse(left.left,left.right);
            Traverse(right.left, right.right);
            //  Connect two child nodes that span the parent node 
            Traverse(left.right, right.left);
        }

Leetcode 114._ The binary tree is expanded into a list

        public void Flatten(TreeNode root)
        {
            if (root == null) return;
            Traverse(root);
        }
        void Traverse(TreeNode root)
        {
            if (root == null) return;
            //  Traverse and flatten the left and right subtrees 
            Traverse(root.left);
            Traverse(root.right);
            //  Post sequence position 
            TreeNode left = root.left;
            TreeNode right = root.right;
            //  Take the left subtree as the right 
            root.left = null;
            root.right = left;
            //  Add the right subtree to the end of the current right subtree 
            TreeNode p = root;
            while (p.right!=null)
            {
                p = p.right;
            }
            p.right = right;
        }