add level order traversal code

ashishps1 · ashishps1 · commit 286d2dc8e978 · 2024-10-28T19:21:16.000+05:30
diff --git a/patterns/c#/LevelOrderTraversal.cs b/patterns/c#/LevelOrderTraversal.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    public TreeNode(int x) {
+        val = x;
+    }
+}
+
+public class LevelOrderTraversal {
+    public void LevelOrder(TreeNode root) {
+        if (root == null) return;
+
+        Queue<TreeNode> queue = new Queue<TreeNode>();
+        queue.Enqueue(root);
+
+        while (queue.Count > 0) {
+            TreeNode node = queue.Dequeue();
+            Console.Write(node.val + " "); // Process the node by printing its value
+            
+            // Add the left and right children to the queue, if they exist
+            if (node.left != null) queue.Enqueue(node.left);
+            if (node.right != null) queue.Enqueue(node.right);
+        }
+    }
+}
diff --git a/patterns/c++/LevelOrderTraversal.cpp b/patterns/c++/LevelOrderTraversal.cpp
@@ -0,0 +1,32 @@
+#include <iostream>
+#include <queue>
+using namespace std;
+
+// Definition for a binary tree node.
+struct TreeNode {
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+};
+
+class LevelOrderTraversal {
+public:
+    void levelOrder(TreeNode* root) {
+        if (root == nullptr) return;
+
+        queue<TreeNode*> q;
+        q.push(root);
+
+        while (!q.empty()) {
+            TreeNode* node = q.front();
+            q.pop();
+            cout << node->val << " "; // Process the node by printing its value
+            
+            // Add the left and right children to the queue, if they exist
+            if (node->left != nullptr) q.push(node->left);
+            if (node->right != nullptr) q.push(node->right);
+        }
+    }
+};
diff --git a/patterns/go/level_order_traversal.go b/patterns/go/level_order_traversal.go
@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+// Definition for a binary tree node.
+type TreeNode struct {
+    Val   int
+    Left  *TreeNode
+    Right *TreeNode
+}
+
+func levelOrder(root *TreeNode) {
+    if root == nil {
+        return
+    }
+
+    queue := []*TreeNode{root}
+
+    for len(queue) > 0 {
+        node := queue[0]
+        queue = queue[1:]
+        fmt.Print(node.Val, " ") // Process the node by printing its value
+        
+        // Add the left and right children to the queue, if they exist
+        if node.Left != nil {
+            queue = append(queue, node.Left)
+        }
+        if node.Right != nil {
+            queue = append(queue, node.Right)
+    }
+}
+
+func main() {
+    // Example usage
+    root := &TreeNode{Val: 1}
+    root.Left = &TreeNode{Val: 2}
+    root.Right = &TreeNode{Val: 3}
+    levelOrder(root) // Output: 1 2 3
+}
diff --git a/patterns/java/LevelOrderTraversal.java b/patterns/java/LevelOrderTraversal.java
@@ -0,0 +1,33 @@
+package patterns.java;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+// Definition for a binary tree node.
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    
+    TreeNode(int x) { 
+        val = x; 
+    }
+}
+
+public class LevelOrderTraversal {
+    public void levelOrder(TreeNode root) {
+        if (root == null) return;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll();
+            System.out.print(node.val + " "); // Process the node by printing its value
+            
+            // Add the left and right children to the queue, if they exist
+            if (node.left != null) queue.add(node.left);
+            if (node.right != null) queue.add(node.right);
+        }
+    }
+}
diff --git a/patterns/javascript/levelOrderTraversal.js b/patterns/javascript/levelOrderTraversal.js
@@ -0,0 +1,24 @@
+// Definition for a binary tree node.
+class TreeNode {
+    constructor(val) {
+        this.val = val;
+        this.left = this.right = null;
+    }
+}
+
+class LevelOrderTraversal {
+    levelOrder(root) {
+        if (root === null) return;
+
+        const queue = [root];
+
+        while (queue.length > 0) {
+            const node = queue.shift();
+            console.log(node.val); // Process the node by printing its value
+            
+            // Add the left and right children to the queue, if they exist
+            if (node.left !== null) queue.push(node.left);
+            if (node.right !== null) queue.push(node.right);
+        }
+    }
+}
diff --git a/patterns/javascript/topKElements.js b/patterns/javascript/topKElements.js
diff --git a/patterns/python/level_order_traversal.py b/patterns/python/level_order_traversal.py
@@ -0,0 +1,25 @@
+from collections import deque
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+class LevelOrderTraversal:
+    def level_order(self, root):
+        if root is None:
+            return
+
+        queue = deque([root])
+
+        while queue:
+            node = queue.popleft()
+            print(node.val, end=" ")  # Process the node by printing its value
+            
+            # Add the left and right children to the queue, if they exist
+            if node.left:
+                queue.append(node.left)
+            if node.right:
+                queue.append(node.right)
diff --git a/patterns/typescript/levelOrderTraversal.ts b/patterns/typescript/levelOrderTraversal.ts
@@ -0,0 +1,28 @@
+// Definition for a binary tree node.
+class BinaryTreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+
+    constructor(val: number) {
+        this.val = val;
+        this.left = this.right = null;
+    }
+}
+
+class BinaryTreeLevelOrderTraversal {
+    levelOrder(root: BinaryTreeNode | null): void {
+        if (root === null) return;
+
+        const queue: BinaryTreeNode[] = [root];
+
+        while (queue.length > 0) {
+            const node = queue.shift()!;
+            console.log(node.val); // Process the node by printing its value
+            
+            // Add the left and right children to the queue, if they exist
+            if (node.left !== null) queue.push(node.left);
+            if (node.right !== null) queue.push(node.right);
+        }
+    }
+}
diff --git a/patterns/typescript/topKElements.ts b/patterns/typescript/topKElements.ts
