Merge branch 'master' into master

Author: siriak

src/main/java/com/thealgorithms/datastructures/trees/SameTreesCheck.java

@@ -0,0 +1,82 @@
+package com.thealgorithms.datastructures.trees;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Given 2 binary trees.
+ * This code checks whether they are the same (structurally identical and have the same values) or not.
+ * <p>
+ * Example:
+ * 1. Binary trees:
+ *      1                 1
+ *     / \               / \
+ *    2   3             2   3
+ *   /\   /\           /\   /\
+ *  4  5 6  7         4  5 6  7
+ * These trees are the same, so the code returns 'true'.
+ * <p>
+ * 2. Binary trees:
+ *      1   1
+ *     /     \
+ *    2       2
+ * These trees are NOT the same (the structure differs), so the code returns 'false'.
+ * <p>
+ * This solution implements the breadth-first search (BFS) algorithm.
+ * For each tree we create a queue and iterate the trees using these queues.
+ * On each step we check the nodes for equality, and if the nodes are not the same, return false.
+ * Otherwise, add children nodes to the queues and continue traversing the trees.
+ * <p>
+ * Complexities:
+ * O(N) - time, where N is the number of nodes in a binary tree,
+ * O(N) - space, where N is the number of nodes in a binary tree.
+ *
+ * @author Albina Gimaletdinova on 13/01/2023
+ */
+public class SameTreesCheck {
+    public static boolean check(BinaryTree.Node p, BinaryTree.Node q) {
+        if (p == null && q == null) {
+            return true;
+        }
+        if (p == null || q == null) {
+            return false;
+        }
+
+        Deque<BinaryTree.Node> q1 = new ArrayDeque<>();
+        Deque<BinaryTree.Node> q2 = new ArrayDeque<>();
+        q1.add(p);
+        q2.add(q);
+        while (!q1.isEmpty() && !q2.isEmpty()) {
+            BinaryTree.Node first = q1.poll();
+            BinaryTree.Node second = q2.poll();
+            // check that some node can be null
+            // if the check is true: both nodes are null or both nodes are not null
+            if (!equalNodes(first, second)) return false;
+
+            if (first != null) {
+                if (!equalNodes(first.left, second.left)) return false;
+                if (first.left != null) {
+                    q1.add(first.left);
+                    q2.add(second.left);
+                }
+
+                if (!equalNodes(first.right, second.right)) return false;
+                if (first.right != null) {
+                    q1.add(first.right);
+                    q2.add(second.right);
+                }
+            }
+        }
+        return true;
+    }
+
+    private static boolean equalNodes(BinaryTree.Node p, BinaryTree.Node q) {
+        if (p == null && q == null) {
+            return true;
+        }
+        if (p == null || q == null) {
+            return false;
+        }
+        return p.data == q.data;
+    }
+}

src/main/java/com/thealgorithms/datastructures/trees/VerticalOrderTraversal.java

@@ -22,23 +22,13 @@
  */
 public class VerticalOrderTraversal {
 
-    public static void main(String[] args) {
-        BinaryTree tree = new BinaryTree();
-        tree.put(5);
-        tree.put(6);
-        tree.put(3);
-        tree.put(1);
-        tree.put(4);
-        BinaryTree.Node root = tree.getRoot();
-        ArrayList<Integer> ans = verticalTraversal(root);
-        for (int i : ans) {
-            System.out.print(i + " ");
+    /*Function that receives a root Node and prints the tree
+	in Vertical Order.*/
+    public static ArrayList<Integer> verticalTraversal(BinaryTree.Node root) {
+        if (root == null) {
+            return new ArrayList<>();
         }
-    }
 
-    /*Function that receives a root Node and prints the tree 
-	in Vertical Order.*/
-    private static ArrayList<Integer> verticalTraversal(BinaryTree.Node root) {
         /*Queue to store the Nodes.*/
         Queue<BinaryTree.Node> queue = new LinkedList<>();
 
@@ -84,21 +74,19 @@ private static ArrayList<Integer> verticalTraversal(BinaryTree.Node root) {
 			 to the respective ArrayList present at that
 			 index. */
             map.get(index.peek()).add(queue.peek().data);
-            max = (int) Math.max(max, index.peek());
-            min = (int) Math.min(min, index.peek());
-            /*The Node and its index are removed 
+            max = Math.max(max, index.peek());
+            min = Math.min(min, index.peek());
+            /*The Node and its index are removed
 			 from their respective queues.*/
             index.poll();
             queue.poll();
         }
         /*Finally map data is printed here which has keys
-		from min to max. Each ArrayList represents a 
+		from min to max. Each ArrayList represents a
 		vertical column that is added in ans ArrayList.*/
         ArrayList<Integer> ans = new ArrayList<>();
         for (int i = min; i <= max; i++) {
-            for (int j = 0; j < map.get(i).size(); j++) {
-                ans.add(map.get(i).get(j));
-            }
+            ans.addAll(map.get(i));
         }
         return ans;
     }

src/main/java/com/thealgorithms/datastructures/trees/ZigzagTraversal.java

@@ -0,0 +1,70 @@
+package com.thealgorithms.datastructures.trees;
+
+import java.util.*;
+
+/**
+ * Given a binary tree.
+ * This code returns the zigzag level order traversal of its nodes' values.
+ * Binary tree:
+ *                               7
+ *                   /                         \
+ *                6                           3
+ *         /                \             /             \
+ *      2                    4         10                19
+ * Zigzag traversal:
+ * [[7], [3, 6], [2, 4, 10, 19]]
+ * <p>
+ * This solution implements the breadth-first search (BFS) algorithm using a queue.
+ * 1. The algorithm starts with a root node. This node is added to a queue.
+ * 2. While the queue is not empty:
+ *  - each time we enter the while-loop we get queue size. Queue size refers to the number of nodes at the current level.
+ *  - we traverse all the level nodes in 2 ways: from left to right OR from right to left
+ *    (this state is stored on `prevLevelFromLeftToRight` variable)
+ *  - if the current node has children we add them to a queue
+ *  - add level with nodes to a result.
+ * <p>
+ * Complexities:
+ * O(N) - time, where N is the number of nodes in a binary tree
+ * O(N) - space, where N is the number of nodes in a binary tree
+ *
+ * @author Albina Gimaletdinova on 11/01/2023
+ */
+public class ZigzagTraversal {
+    public static List<List<Integer>> traverse(BinaryTree.Node root) {
+        if (root == null) {
+            return new ArrayList<>();
+        }
+
+        List<List<Integer>> result = new ArrayList<>();
+
+        // create a queue
+        Deque<BinaryTree.Node> q = new ArrayDeque<>();
+        q.offer(root);
+        // start with writing nodes from left to right
+        boolean prevLevelFromLeftToRight = false;
+
+        while (!q.isEmpty()) {
+            int nodesOnLevel = q.size();
+            List<Integer> level = new LinkedList<>();
+            // traverse all the level nodes
+            for (int i = 0; i < nodesOnLevel; i++) {
+                BinaryTree.Node node = q.poll();
+                if (prevLevelFromLeftToRight) {
+                    level.add(0, node.data);
+                } else {
+                    level.add(node.data);
+                }
+                if (node.left != null) {
+                    q.offer(node.left);
+                }
+                if (node.right != null) {
+                    q.offer(node.right);
+                }
+            }
+            // the next level node traversal will be from the other side
+            prevLevelFromLeftToRight = !prevLevelFromLeftToRight;
+            result.add(level);
+        }
+        return result;
+    }
+}