Merge pull request #169 from fartem/reverse-odd-levels-of-binary-tree

2023-01-21 update: added "2415. Reverse Odd Levels of Binary Tree"

Author: fartem

Diff for: README.md

@@ -742,6 +742,7 @@ Profile on LeetCode: [fartem](https://leetcode.com/fartem/).
 | 2326. Spiral Matrix IV                                                              | [Link](https://leetcode.com/problems/spiral-matrix-iv/)                                                              | [Link](./src/main/java/com/smlnskgmail/jaman/leetcodejava/medium/SpiralMatrixIV.java)                                                  |
 | 2375. Construct Smallest Number From DI String                                      | [Link](https://leetcode.com/problems/construct-smallest-number-from-di-string/)                                      | [Link](./src/main/java/com/smlnskgmail/jaman/leetcodejava/medium/ConstructSmallestNumberFromDIString.java)                             |
 | 2390. Removing Stars From a String                                                  | [Link](https://leetcode.com/problems/removing-stars-from-a-string/)                                                  | [Link](./src/main/java/com/smlnskgmail/jaman/leetcodejava/medium/RemovingStarsFromAString.java)                                        |
+| 2415. Reverse Odd Levels of Binary Tree                                             | [Link](https://leetcode.com/problems/reverse-odd-levels-of-binary-tree/)                                             | [Link](./src/main/java/com/smlnskgmail/jaman/leetcodejava/medium/ReverseOddLevelsOfBinaryTree.java)                                    |
 
 ### Hard
 

Diff for: src/main/java/com/smlnskgmail/jaman/leetcodejava/medium/ReverseOddLevelsOfBinaryTree.java

@@ -0,0 +1,32 @@
+package com.smlnskgmail.jaman.leetcodejava.medium;
+
+import com.smlnskgmail.jaman.leetcodejava.support.TreeNode;
+
+// https://leetcode.com/problems/reverse-odd-levels-of-binary-tree/
+public class ReverseOddLevelsOfBinaryTree {
+
+    private final TreeNode input;
+
+    public ReverseOddLevelsOfBinaryTree(TreeNode input) {
+        this.input = input;
+    }
+
+    public TreeNode solution() {
+        traverse(input.left, input.right, 1);
+        return input;
+    }
+
+    private void traverse(TreeNode l, TreeNode r, int level) {
+        if (l == null || r == null) {
+            return;
+        }
+        if (level % 2 == 1) {
+            int temp = l.val;
+            l.val = r.val;
+            r.val = temp;
+        }
+        traverse(l.left, r.right, level + 1);
+        traverse(l.right, r.left, level + 1);
+    }
+
+}

Diff for: src/main/java/com/smlnskgmail/jaman/leetcodejava/support/TreeNode.java

@@ -1,8 +1,7 @@
 package com.smlnskgmail.jaman.leetcodejava.support;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
+import java.util.LinkedList;
+import java.util.Queue;
 
 public class TreeNode {
 
@@ -16,6 +15,26 @@ public static boolean areEqual(TreeNode n1, TreeNode n2) {
         return n1 == null && n2 == null;
     }
 
+    public static TreeNode perfectFromArray(int... tree) {
+        if (tree.length == 0) return null;
+        TreeNode root = new TreeNode(tree[0]);
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        for (int i = 1; i < tree.length; i++) {
+            TreeNode node = q.peek();
+            assert node != null;
+            if (node.left == null) {
+                node.left = new TreeNode(tree[i]);
+                q.add(node.left);
+            } else if (node.right == null) {
+                node.right = new TreeNode(tree[i]);
+                q.add(node.right);
+                q.remove();
+            }
+        }
+        return root;
+    }
+
     public int val;
     public TreeNode left;
     public TreeNode right;

Diff for: src/test/java/com/smlnskgmail/jaman/leetcodejava/medium/ReverseOddLevelsOfBinaryTreeTest.java

@@ -0,0 +1,46 @@
+package com.smlnskgmail.jaman.leetcodejava.medium;
+
+import com.smlnskgmail.jaman.leetcodejava.support.TreeNode;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class ReverseOddLevelsOfBinaryTreeTest {
+
+    @Test
+    public void defaultTests() {
+        assertTrue(
+                TreeNode.areEqual(
+                        TreeNode.perfectFromArray(
+                                2, 5, 3, 8, 13, 21, 34
+                        ),
+                        new ReverseOddLevelsOfBinaryTree(
+                                TreeNode.perfectFromArray(
+                                        2, 3, 5, 8, 13, 21, 34
+                                )
+                        ).solution()
+                )
+        );
+        assertTrue(
+                TreeNode.areEqual(
+                        TreeNode.perfectFromArray(7, 11, 13),
+                        new ReverseOddLevelsOfBinaryTree(
+                                TreeNode.perfectFromArray(7, 13, 11)
+                        ).solution()
+                )
+        );
+        assertTrue(
+                TreeNode.areEqual(
+                        TreeNode.perfectFromArray(
+                                0, 2, 1, 0, 0, 0, 0, 2, 2, 2, 2, 1, 1, 1, 1
+                        ),
+                        new ReverseOddLevelsOfBinaryTree(
+                                TreeNode.perfectFromArray(
+                                        0, 1, 2, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2
+                                )
+                        ).solution()
+                )
+        );
+    }
+
+}