#226: Invert Binary Tree; solution & tests

Author: vetalapo

c-sharp/Problems/trees/InvertBinaryTree.cs

@@ -0,0 +1,62 @@
+/**
+ * 226
+ * Invert Binary Tree
+ **
+ * Given the root of a binary tree,
+ * invert the tree,
+ * and return its root.
+ *
+ * Example 1:
+ *   Input: root = [4,2,7,1,3,6,9]
+ *   Output: [4,7,2,9,6,3,1]
+ *
+ * Example 2:
+ *   Input: root = [2,1,3]
+ *   Output: [2,3,1]
+ *
+ * Example 3:
+ *   Input: root = []
+ *   Output: []
+ *
+ * Constraints:
+ *   • The number of nodes in the tree is in the range [0, 100].
+ *   • -100 <= Node.val <= 100
+ **
+ * https://leetcode.com/problems/invert-binary-tree/
+***/
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+***/
+
+using Problems.Common;
+
+namespace Problems;
+
+public class InvertBinaryTree
+{
+    public TreeNode InvertTree( TreeNode root )
+    {
+        if ( root is null )
+        {
+            return root;
+        }
+
+        (root.left, root.right) = (root.right, root.left);
+
+        InvertTree( root.left );
+        InvertTree( root.right );
+
+        return root;
+    }
+}

c-sharp/Problems/trees/common/TreeNode.cs

@@ -70,6 +70,61 @@ public static TreeNode CreateBST( int[] values )
         return result;
     }
 
+    // BST: Binary Search Tree
+    public static TreeNode CreateDescBST( int[] values )
+    {
+        if ( values.Length == 0 )
+        {
+            return null;
+        }
+
+        TreeNode result = new()
+        {
+            val = values[0]
+        };
+
+        for ( int i = 1; i < values.Length; i++ )
+        {
+            TreeNode temp = result;
+
+            while ( true )
+            {
+                if ( values[i] == temp.val )
+                {
+                    break;
+                }
+                else if ( values[i] < temp.val )
+                {
+                    if ( temp.right is null )
+                    {
+                        temp.right = new TreeNode( values[i] );
+
+                        break;
+                    }
+                    else
+                    {
+                        temp = temp.right;
+                    }
+                }
+                else
+                {
+                    if ( temp.left is null )
+                    {
+                        temp.left = new TreeNode( values[i] );
+
+                        break;
+                    }
+                    else
+                    {
+                        temp = temp.left;
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
     public override bool Equals( object? obj )
     {
         return obj is TreeNode treeNode &&

c-sharp/Tests/trees/InvertBinaryTreeTests.cs

@@ -0,0 +1,28 @@
+using System.Collections;
+
+using NUnit.Framework;
+
+using Problems;
+using Problems.Common;
+
+public class InvertBinaryTreeTests
+{
+    [TestCaseSource( nameof( TestCases ) )]
+    public TreeNode InvertTreeTest( TreeNode root ) =>
+        new InvertBinaryTree().InvertTree( root );
+
+    private static IEnumerable TestCases
+    {
+        get
+        {
+            yield return new TestCaseData( TreeNode.CreateBST( [4, 2, 7, 1, 3, 6, 9] ) )
+                .Returns( TreeNode.CreateDescBST( [4, 7, 2, 9, 6, 3, 1] ) );
+
+            yield return new TestCaseData( TreeNode.CreateBST( [2, 1, 3] ) )
+                .Returns( TreeNode.CreateDescBST( [2, 3, 1] ) );
+
+            yield return new TestCaseData( TreeNode.CreateBST( [] ) )
+                .Returns( TreeNode.CreateDescBST( [] ) );
+        }
+    }
+}