add solution in other languages

Author: ashishps1

c#/01_matrix.md

@@ -1,2 +1,67 @@
-# 01_matrix.md
+# 542. [01 Matrix](https://leetcode.com/problems/01-matrix/)
+
+## Approach: Breadth-First Search (BFS)
+
+### Solution
+```csharp
+// Time Complexity: O(m * n), where m is the number of rows and n is the number of columns
+// Space Complexity: O(m * n), for the queue and distance matrix
+using System.Collections.Generic;
+
+public class Solution 
+{
+    public int[][] UpdateMatrix(int[][] mat) 
+    {
+        int rows = mat.Length;
+        int cols = mat[0].Length;
+        int[][] distances = new int[rows][];
+        bool[][] visited = new bool[rows][];
+        Queue<int[]> queue = new Queue<int[]>();
+
+        // Step 1: Initialize the queue with all '0' cells and mark them as visited
+        for (int i = 0; i < rows; i++) 
+        {
+            distances[i] = new int[cols];
+            visited[i] = new bool[cols];
+            for (int j = 0; j < cols; j++) 
+            {
+                if (mat[i][j] == 0) 
+                {
+                    queue.Enqueue(new int[] { i, j });
+                    visited[i][j] = true;
+                }
+            }
+        }
+
+        // Step 2: Perform BFS to calculate distances
+        int[][] directions = new int[][] 
+        {
+            new int[] { 0, 1 },
+            new int[] { 1, 0 },
+            new int[] { 0, -1 },
+            new int[] { -1, 0 }
+        };
+
+        while (queue.Count > 0) 
+        {
+            int[] current = queue.Dequeue();
+            foreach (int[] dir in directions) 
+            {
+                int newRow = current[0] + dir[0];
+                int newCol = current[1] + dir[1];
+
+                // Check bounds and if the cell is not visited
+                if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols && !visited[newRow][newCol]) 
+                {
+                    distances[newRow][newCol] = distances[current[0]][current[1]] + 1;
+                    queue.Enqueue(new int[] { newRow, newCol });
+                    visited[newRow][newCol] = true;
+                }
+            }
+        }
+
+        return distances;
+    }
+}
+```
 

c#/all_paths_from_source_to_target.md

@@ -1,2 +1,36 @@
-# all_paths_from_source_to_target.md
+# 797. [All Paths From Source to Target](https://leetcode.com/problems/all-paths-from-source-to-target/)
+
+## Approach: Depth-First Search (DFS)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(2^n * n), where n is the number of nodes in the graph
+// Space Complexity: O(2^n * n), for storing all paths in the result
+using System.Collections.Generic;
+
+public class Solution {
+    public IList<IList<int>> AllPathsSourceTarget(int[][] graph) {
+        List<IList<int>> result = new List<IList<int>>();
+        List<int> path = new List<int>();
+        path.Add(0); // Start from the source node
+        DFS(graph, 0, path, result);
+        return result;
+    }
+
+    private void DFS(int[][] graph, int node, List<int> path, List<IList<int>> result) {
+        if (node == graph.Length - 1) {
+            // If we reach the target node, add the current path to the result
+            result.Add(new List<int>(path));
+            return;
+        }
+
+        foreach (int neighbor in graph[node]) {
+            path.Add(neighbor); // Add the neighbor to the current path
+            DFS(graph, neighbor, path, result); // Recur for the neighbor
+            path.RemoveAt(path.Count - 1); // Backtrack to explore other paths
+        }
+    }
+}
+```
 

c#/binary_search_tree_iterator.md

@@ -1,2 +1,177 @@
-# binary_search_tree_iterator.md
+# 173. [Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/)
+
+## Approach 1: Controlled Recursion Using Stack
+
+### Solution
+```csharp
+// Time Complexity:
+//   - Constructor: O(h), where h is the height of the tree
+//   - Next(): O(1) on average across all calls
+//   - HasNext(): O(1)
+// Space Complexity: O(h), where h is the height of the tree for the stack
+using System.Collections.Generic;
+
+public class BSTIterator
+{
+    private Stack<TreeNode> stack;
+
+    public BSTIterator(TreeNode root)
+    {
+        stack = new Stack<TreeNode>();
+        PushLeft(root);
+    }
+
+    // Push all left children of the current node to the stack
+    private void PushLeft(TreeNode node)
+    {
+        while (node != null)
+        {
+            stack.Push(node);
+            node = node.left;
+        }
+    }
+
+    /** @return the next smallest number */
+    public int Next()
+    {
+        TreeNode node = stack.Pop(); // Get the topmost node (smallest available)
+        if (node.right != null)
+        {
+            PushLeft(node.right); // Process the right subtree
+        }
+        return node.val;
+    }
+
+    /** @return whether we have a next smallest number */
+    public bool HasNext()
+    {
+        return stack.Count > 0; // Check if the stack is non-empty
+    }
+}
+
+public class TreeNode
+{
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+    public TreeNode(int x) { val = x; }
+}
+```
+
+## Approach 2: Precomputed Inorder Traversal
+
+### Solution
+```csharp
+// Time Complexity:
+//   - Constructor: O(n), where n is the number of nodes in the tree
+//   - Next(): O(1)
+//   - HasNext(): O(1)
+// Space Complexity: O(n), where n is the number of nodes in the tree
+using System.Collections.Generic;
+
+public class BSTIterator
+{
+    private List<int> inorder;
+    private int index;
+
+    public BSTIterator(TreeNode root)
+    {
+        inorder = new List<int>();
+        index = 0;
+        InorderTraversal(root);
+    }
+
+    // Perform an inorder traversal to store the elements
+    private void InorderTraversal(TreeNode node)
+    {
+        if (node == null)
+        {
+            return;
+        }
+        InorderTraversal(node.left);
+        inorder.Add(node.val);
+        InorderTraversal(node.right);
+    }
+
+    /** @return the next smallest number */
+    public int Next()
+    {
+        return inorder[index++];
+    }
+
+    /** @return whether we have a next smallest number */
+    public bool HasNext()
+    {
+        return index < inorder.Count;
+    }
+}
+```
+
+## Approach 3: Morris Traversal (Space Optimized, Less Practical for Iterator)
+
+### Solution
+```csharp
+// Time Complexity:
+//   - Constructor: O(1) (no precomputation)
+//   - Next(): O(1) on average across all calls
+//   - HasNext(): O(1)
+// Space Complexity: O(1), no additional storage
+public class BSTIterator
+{
+    private TreeNode current;
+    private TreeNode predecessor;
+
+    public BSTIterator(TreeNode root)
+    {
+        current = root;
+    }
+
+    /** @return the next smallest number */
+    public int Next()
+    {
+        int value = -1;
+
+        while (current != null)
+        {
+            if (current.left == null)
+            {
+                value = current.val;
+                current = current.right; // Move to the right subtree
+                break;
+            }
+            else
+            {
+                predecessor = current.left;
+
+                // Find the rightmost node in the left subtree
+                while (predecessor.right != null && predecessor.right != current)
+                {
+                    predecessor = predecessor.right;
+                }
+
+                if (predecessor.right == null)
+                {
+                    predecessor.right = current; // Create a temporary link
+                    current = current.left;
+                }
+                else
+                {
+                    predecessor.right = null; // Remove the temporary link
+                    value = current.val;
+                    current = current.right; // Move to the right subtree
+                    break;
+                }
+            }
+        }
+
+        return value;
+    }
+
+    /** @return whether we have a next smallest number */
+    public bool HasNext()
+    {
+        return current != null;
+    }
+}
+```
 

c#/binary_tree_inorder_traversal.md

@@ -1,2 +1,103 @@
-# binary_tree_inorder_traversal.md
+# 94. [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)
+
+## Approach 1: Recursive Inorder Traversal
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n), where n is the number of nodes in the tree
+// Space Complexity: O(h), where h is the height of the tree for recursion stack
+using System.Collections.Generic;
+
+public class Solution {
+    public IList<int> InorderTraversal(TreeNode root) {
+        List<int> result = new List<int>();
+        Inorder(root, result);
+        return result;
+    }
+
+    private void Inorder(TreeNode node, List<int> result) {
+        if (node == null) {
+            return; // Base case: if the node is null, return
+        }
+
+        Inorder(node.left, result); // Recurse for the left subtree
+        result.Add(node.val); // Visit the root
+        Inorder(node.right, result); // Recurse for the right subtree
+    }
+}
+```
+
+## Approach 2: Iterative Inorder Traversal Using Stack
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n), where n is the number of nodes in the tree
+// Space Complexity: O(h), where h is the height of the tree for the stack
+using System.Collections.Generic;
+
+public class Solution {
+    public IList<int> InorderTraversal(TreeNode root) {
+        List<int> result = new List<int>();
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        TreeNode current = root;
+
+        while (current != null || stack.Count > 0) {
+            while (current != null) {
+                stack.Push(current); // Push the current node and move to the left subtree
+                current = current.left;
+            }
+
+            current = stack.Pop(); // Process the top node
+            result.Add(current.val); // Visit the node
+            current = current.right; // Move to the right subtree
+        }
+
+        return result;
+    }
+}
+```
+
+## Approach 3: Morris Inorder Traversal (Without Recursion or Stack)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n), where n is the number of nodes in the tree
+// Space Complexity: O(1), as no additional space is used
+using System.Collections.Generic;
+
+public class Solution {
+    public IList<int> InorderTraversal(TreeNode root) {
+        List<int> result = new List<int>();
+        TreeNode current = root;
+
+        while (current != null) {
+            if (current.left == null) {
+                result.Add(current.val); // Visit the node
+                current = current.right; // Move to the right subtree
+            } else {
+                TreeNode predecessor = current.left;
+
+                // Find the rightmost node in the left subtree
+                while (predecessor.right != null && predecessor.right != current) {
+                    predecessor = predecessor.right;
+                }
+
+                if (predecessor.right == null) {
+                    predecessor.right = current; // Create a temporary thread to the root
+                    current = current.left; // Move to the left subtree
+                } else {
+                    predecessor.right = null; // Remove the temporary thread
+                    result.Add(current.val); // Visit the node
+                    current = current.right; // Move to the right subtree
+                }
+            }
+        }
+
+        return result;
+    }
+}
+```