Improved task 102

Author: javadev

src/main/swift/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md

@@ -32,20 +32,53 @@ Given the `root` of a binary tree, return _the level order traversal of its node
 *   The number of nodes in the tree is in the range `[0, 2000]`.
 *   `-1000 <= Node.val <= 1000`
 
-To solve the "Binary Tree Level Order Traversal" problem in Java with a `Solution` class, we'll perform a breadth-first search (BFS) traversal of the binary tree. Below are the steps:
-
-1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
-
-2. **Create a `levelOrder` method**: This method takes the root node of the binary tree as input and returns the level order traversal of its nodes' values.
-
-3. **Initialize a queue**: Create a queue to store the nodes during BFS traversal.
-
-4. **Check for null root**: Check if the root is null. If it is, return an empty list.
-
-5. **Perform BFS traversal**: Enqueue the root node into the queue. While the queue is not empty:
-   - Dequeue the front node from the queue.
-   - Add the value of the dequeued node to the current level list.
-   - Enqueue the left and right children of the dequeued node if they exist.
-   - Move to the next level when all nodes in the current level are processed.
-
-6. **Return the result**: After the BFS traversal is complete, return the list containing the level order traversal of the binary tree.
+## Solution
+
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func levelOrder(_ root: TreeNode?) -> [[Int]] {
+        var result = [[Int]]()
+        guard let root = root else {
+            return result
+        }
+        
+        var queue: [TreeNode?] = [root, nil]
+        var level = [Int]()
+        
+        while !queue.isEmpty {
+            let node = queue.removeFirst()
+            if let node = node {
+                level.append(node.val)
+                if let left = node.left {
+                    queue.append(left)
+                }
+                if let right = node.right {
+                    queue.append(right)
+                }
+            } else {
+                result.append(level)
+                level = [Int]()
+                if !queue.isEmpty {
+                    queue.append(nil)
+                }
+            }
+        }
+        return result
+    }
+}
+```