From f01403b972f7333869f90ff2c07463923cf88049 Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sat, 12 Jun 2021 22:00:59 +0300 Subject: [PATCH 01/12] 314-Add Initial Solution --- .../BinaryTreeVerticalOrderTraversalBFS.java | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java new file mode 100644 index 00000000..93d132e1 --- /dev/null +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -0,0 +1,69 @@ +package algorithms.curated170.medium.braceexpansion; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.TreeMap; + +import algorithms.datastructures.TreeNode; + +public class BinaryTreeVerticalOrderTraversalBFS { + public List> verticalOrder(TreeNode root) { + + if (root == null) { + return new ArrayList<>(); + } + + TreeMap> tree = new TreeMap<>(); + + Deque q = new ArrayDeque<>(); + q.offer(new Pair(root, 0)); + + while (!q.isEmpty()) { + Pair p = q.poll(); + + tree.putIfAbsent(p.x, new ArrayList<>()); + tree.get(p.x).add(p.tn.val); + + if (p.tn.left != null) { + q.offer(new Pair(p.tn.left, p.x - 1)); + } + + if (p.tn.right != null) { + q.offer(new Pair(p.tn.right, p.x + 1)); + } + } + + List> ret = new ArrayList<>(); + + for (var k : tree.values()) { + ret.add(k); + } + + return ret; + } + + private class Pair { + TreeNode tn; + int x = 0; + + Pair(TreeNode tn, int x) { + this.tn = tn; + this.x = x; + } + } + + public static void main(String[] args) { + var solution = new BinaryTreeVerticalOrderTraversalBFS(); + + TreeNode tn1 = new TreeNode(1); + TreeNode t0 = new TreeNode(2, null, tn1); + TreeNode t1 = new TreeNode(5); + TreeNode t2 = new TreeNode(4, null, t1); + TreeNode t3 = new TreeNode(3, t0, t2); + TreeNode root = new TreeNode(9, null, t3); + + System.out.println(solution.verticalOrder(root)); + } +} From 29dc56d7b39cb0fe7ddb7c881b4564ac4de0e593 Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 10:21:56 +0300 Subject: [PATCH 02/12] 314-Refactor BFS Solution --- .../BinaryTreeVerticalOrderTraversalBFS.java | 54 ++++++++++--------- 1 file changed, 29 insertions(+), 25 deletions(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index 93d132e1..b1d68521 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -2,6 +2,7 @@ import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Collections; import java.util.Deque; import java.util.List; import java.util.TreeMap; @@ -12,44 +13,47 @@ public class BinaryTreeVerticalOrderTraversalBFS { public List> verticalOrder(TreeNode root) { if (root == null) { - return new ArrayList<>(); + return Collections.emptyList(); } - TreeMap> tree = new TreeMap<>(); + TreeMap> xPosMap = new TreeMap<>(); - Deque q = new ArrayDeque<>(); - q.offer(new Pair(root, 0)); + Deque q = new ArrayDeque<>(); + q.offer(new NodePosPair(root, 0)); while (!q.isEmpty()) { - Pair p = q.poll(); + NodePosPair npp = q.poll(); + npp.placeIntoMap(xPosMap); + npp.queueChildren(q); + } - tree.putIfAbsent(p.x, new ArrayList<>()); - tree.get(p.x).add(p.tn.val); + List> verticalOrderAtXPos = new ArrayList<>(xPosMap.values()); - if (p.tn.left != null) { - q.offer(new Pair(p.tn.left, p.x - 1)); - } + verticalOrderAtXPos.addAll(xPosMap.values()); - if (p.tn.right != null) { - q.offer(new Pair(p.tn.right, p.x + 1)); - } - } + return verticalOrderAtXPos; + } - List> ret = new ArrayList<>(); + private class NodePosPair { + final TreeNode node; + final int x; - for (var k : tree.values()) { - ret.add(k); + void placeIntoMap(TreeMap> xPosMap) { + xPosMap.putIfAbsent(x, new ArrayList<>()); + xPosMap.get(x).add(node.val); } - - return ret; - } - private class Pair { - TreeNode tn; - int x = 0; + void queueChildren(Deque q) { + if (node.left != null) { + q.offer(new NodePosPair(node.left, x - 1)); + } + if (node.right != null) { + q.offer(new NodePosPair(node.right, x + 1)); + } + } - Pair(TreeNode tn, int x) { - this.tn = tn; + NodePosPair(TreeNode tn, int x) { + this.node = tn; this.x = x; } } From a861aff908af814f7a722c829c08dc39b92ce0e1 Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 10:34:56 +0300 Subject: [PATCH 03/12] 314-Add Improved BFS Solution --- .../BinaryTreeVerticalOrderTraversalBFS.java | 39 ++++++---- ...TreeVerticalOrderTraversalBFSTreeNode.java | 73 +++++++++++++++++++ 2 files changed, 99 insertions(+), 13 deletions(-) create mode 100644 src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index b1d68521..86f629bb 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -10,36 +10,49 @@ import algorithms.datastructures.TreeNode; public class BinaryTreeVerticalOrderTraversalBFS { - public List> verticalOrder(TreeNode root) { + public List> verticalOrder(TreeNode root) { if (root == null) { return Collections.emptyList(); } + + int[] range = new int[] {0, 0}; + getRange(root, range, 0); - TreeMap> xPosMap = new TreeMap<>(); - + List> columnsAtXPos = new ArrayList<>(); + for (int i = range[0]; i <= range[1]; i++) { + columnsAtXPos.add(new ArrayList()); + } + Deque q = new ArrayDeque<>(); - q.offer(new NodePosPair(root, 0)); + q.offer(new NodePosPair(root, -1*range[0])); while (!q.isEmpty()) { NodePosPair npp = q.poll(); - npp.placeIntoMap(xPosMap); + npp.placeIntoMap(columnsAtXPos); npp.queueChildren(q); } + + + return columnsAtXPos; +} - List> verticalOrderAtXPos = new ArrayList<>(xPosMap.values()); - - verticalOrderAtXPos.addAll(xPosMap.values()); - - return verticalOrderAtXPos; - } +public void getRange(TreeNode root, int[] range, int col) { + if (root == null) { + return; + } + range[0] = Math.min(range[0], col); + range[1] = Math.max(range[1], col); + + getRange(root.left, range, col - 1); + getRange(root.right, range, col + 1); +} private class NodePosPair { final TreeNode node; final int x; - void placeIntoMap(TreeMap> xPosMap) { - xPosMap.putIfAbsent(x, new ArrayList<>()); + void placeIntoMap(List> xPosMap) { xPosMap.get(x).add(node.val); } diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java new file mode 100644 index 00000000..6f0dc5d2 --- /dev/null +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java @@ -0,0 +1,73 @@ +package algorithms.curated170.medium.braceexpansion; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Deque; +import java.util.List; +import java.util.TreeMap; + +import algorithms.datastructures.TreeNode; + +public class BinaryTreeVerticalOrderTraversalBFSTreeNode { + public List> verticalOrder(TreeNode root) { + + if (root == null) { + return Collections.emptyList(); + } + + TreeMap> xPosMap = new TreeMap<>(); + + Deque q = new ArrayDeque<>(); + q.offer(new NodePosPair(root, 0)); + + while (!q.isEmpty()) { + NodePosPair npp = q.poll(); + npp.placeIntoMap(xPosMap); + npp.queueChildren(q); + } + + List> columnsAtXPos = new ArrayList<>(xPosMap.values()); + + columnsAtXPos.addAll(xPosMap.values()); + + return columnsAtXPos; + } + + private class NodePosPair { + final TreeNode node; + final int x; + + void placeIntoMap(TreeMap> xPosMap) { + xPosMap.putIfAbsent(x, new ArrayList<>()); + xPosMap.get(x).add(node.val); + } + + void queueChildren(Deque q) { + if (node.left != null) { + q.offer(new NodePosPair(node.left, x - 1)); + } + if (node.right != null) { + q.offer(new NodePosPair(node.right, x + 1)); + } + } + + NodePosPair(TreeNode tn, int x) { + this.node = tn; + this.x = x; + } + } + + public static void main(String[] args) { + var solution = new BinaryTreeVerticalOrderTraversalBFSTreeNode(); + + TreeNode tn1 = new TreeNode(1); + TreeNode t0 = new TreeNode(2, null, tn1); + TreeNode t1 = new TreeNode(5); + TreeNode t2 = new TreeNode(4, null, t1); + TreeNode t3 = new TreeNode(3, t0, t2); + TreeNode root = new TreeNode(9, null, t3); + + System.out.println(solution.verticalOrder(root)); + } +} From a318f05791987ec270dffc0674bf9283c172b362 Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 10:47:41 +0300 Subject: [PATCH 04/12] 314-Add Initial DFS Solution --- .../BinaryTreeVerticalOrderTraversalDFS.java | 63 +++++++++++++++++++ .../java/algorithms/datastructures/Pair.java | 15 +++++ 2 files changed, 78 insertions(+) create mode 100644 src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java create mode 100644 src/main/java/algorithms/datastructures/Pair.java diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java new file mode 100644 index 00000000..0b16438c --- /dev/null +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java @@ -0,0 +1,63 @@ +package algorithms.curated170.medium.braceexpansion; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import algorithms.datastructures.Pair; +import algorithms.datastructures.TreeNode; + +public class BinaryTreeVerticalOrderTraversalDFS { + + Map>> columnTable = new HashMap<>(); + int minColumn = 0, maxColumn = 0; + + public List> verticalOrder(TreeNode root) { + List> output = new ArrayList<>(); + if (root == null) { + return output; + } + + this.DFS(root, 0, 0); + + // Retrieve the resuts, by ordering by column and sorting by row + for (int i = minColumn; i < maxColumn + 1; ++i) { + + Collections.sort(columnTable.get(i), new Comparator>() { + @Override + public int compare(Pair p1, Pair p2) { + return p1.first - p2.first; + } + }); + + List sortedColumn = new ArrayList<>(); + for (Pair p : columnTable.get(i)) { + sortedColumn.add(p.second); + } + output.add(sortedColumn); + } + + return output; + } + + private void DFS(TreeNode node, Integer row, Integer column) { + if (node == null) + return; + + if (!columnTable.containsKey(column)) { + this.columnTable.put(column, new ArrayList>()); + } + + this.columnTable.get(column).add(new Pair(row, node.val)); + this.minColumn = Math.min(minColumn, column); + this.maxColumn = Math.max(maxColumn, column); + // preorder DFS traversal + this.DFS(node.left, row + 1, column - 1); + this.DFS(node.right, row + 1, column + 1); + } + +} diff --git a/src/main/java/algorithms/datastructures/Pair.java b/src/main/java/algorithms/datastructures/Pair.java new file mode 100644 index 00000000..f66171a6 --- /dev/null +++ b/src/main/java/algorithms/datastructures/Pair.java @@ -0,0 +1,15 @@ +package algorithms.datastructures; + +public class Pair { + public T1 first; + public T2 second; + + public Pair() { + + } + + public Pair(T1 first, T2 second) { + this.first = first; + this.second = second; + } +} From 1da5c3bc2e277de6635bc9f1a758758edd5e94ca Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 11:06:26 +0300 Subject: [PATCH 05/12] 314-Refactor DFS Solution --- .../BinaryTreeVerticalOrderTraversalDFS.java | 60 ++++++++++--------- 1 file changed, 33 insertions(+), 27 deletions(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java index 0b16438c..a87e8fc0 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java @@ -1,42 +1,34 @@ package algorithms.curated170.medium.braceexpansion; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; -import java.util.Comparator; import java.util.HashMap; import java.util.List; -import java.util.Map; -import algorithms.datastructures.Pair; import algorithms.datastructures.TreeNode; public class BinaryTreeVerticalOrderTraversalDFS { - Map>> columnTable = new HashMap<>(); + HashMap> columnTable = new HashMap<>(); int minColumn = 0, maxColumn = 0; public List> verticalOrder(TreeNode root) { - List> output = new ArrayList<>(); if (root == null) { - return output; + return Collections.emptyList(); } - - this.DFS(root, 0, 0); + + DFS(root, 0, 0); + + List> output = new ArrayList<>(); // Retrieve the resuts, by ordering by column and sorting by row for (int i = minColumn; i < maxColumn + 1; ++i) { - Collections.sort(columnTable.get(i), new Comparator>() { - @Override - public int compare(Pair p1, Pair p2) { - return p1.first - p2.first; - } - }); + Collections.sort(columnTable.get(i), (p1,p2) -> p1[0] - p2[0]); List sortedColumn = new ArrayList<>(); - for (Pair p : columnTable.get(i)) { - sortedColumn.add(p.second); + for (int[] p : columnTable.get(i)) { + sortedColumn.add(p[1]); } output.add(sortedColumn); } @@ -44,20 +36,34 @@ public int compare(Pair p1, Pair p2) { return output; } - private void DFS(TreeNode node, Integer row, Integer column) { - if (node == null) + private void DFS(TreeNode root, Integer row, Integer col) { + + if (root == null){ return; - - if (!columnTable.containsKey(column)) { - this.columnTable.put(column, new ArrayList>()); } - this.columnTable.get(column).add(new Pair(row, node.val)); - this.minColumn = Math.min(minColumn, column); - this.maxColumn = Math.max(maxColumn, column); + columnTable.putIfAbsent(col, new ArrayList<>()); + + columnTable.get(col).add(new int[]{row, root.val}); + minColumn = Math.min(minColumn, col); + maxColumn = Math.max(maxColumn, col); // preorder DFS traversal - this.DFS(node.left, row + 1, column - 1); - this.DFS(node.right, row + 1, column + 1); + DFS(root.left, row + 1, col - 1); + DFS(root.right, row + 1, col + 1); + } + + + public static void main(String[] args) { + var solution = new BinaryTreeVerticalOrderTraversalDFS(); + + TreeNode tn1 = new TreeNode(1); + TreeNode t0 = new TreeNode(2, null, tn1); + TreeNode t1 = new TreeNode(5); + TreeNode t2 = new TreeNode(4, null, t1); + TreeNode t3 = new TreeNode(3, t0, t2); + TreeNode root = new TreeNode(9, null, t3); + + System.out.println(solution.verticalOrder(root)); } } From e9291e522e866e3d542e67db6726b91a16dc30d0 Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 11:27:29 +0300 Subject: [PATCH 06/12] 314-Update All Solutions --- .../BinaryTreeVerticalOrderTraversalBFS.java | 11 +++++-- ...TreeVerticalOrderTraversalBFSTreeNode.java | 14 ++++---- .../BinaryTreeVerticalOrderTraversalDFS.java | 33 ++++++++++--------- 3 files changed, 31 insertions(+), 27 deletions(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index 86f629bb..2648d15c 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -11,15 +11,18 @@ public class BinaryTreeVerticalOrderTraversalBFS { + int nodeCount; public List> verticalOrder(TreeNode root) { if (root == null) { return Collections.emptyList(); } + nodeCount = 0; int[] range = new int[] {0, 0}; getRange(root, range, 0); - List> columnsAtXPos = new ArrayList<>(); + List> columnsAtXPos = new ArrayList<>(range[1]-range[0] + 2); + for (int i = range[0]; i <= range[1]; i++) { columnsAtXPos.add(new ArrayList()); } @@ -41,6 +44,8 @@ public void getRange(TreeNode root, int[] range, int col) { if (root == null) { return; } + + nodeCount++; range[0] = Math.min(range[0], col); range[1] = Math.max(range[1], col); @@ -52,8 +57,8 @@ private class NodePosPair { final TreeNode node; final int x; - void placeIntoMap(List> xPosMap) { - xPosMap.get(x).add(node.val); + void placeIntoMap(List> columnTable) { + columnTable.get(x).add(node.val); } void queueChildren(Deque q) { diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java index 6f0dc5d2..fbdd664e 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java @@ -16,20 +16,18 @@ public List> verticalOrder(TreeNode root) { return Collections.emptyList(); } - TreeMap> xPosMap = new TreeMap<>(); + TreeMap> columnTable = new TreeMap<>(); Deque q = new ArrayDeque<>(); q.offer(new NodePosPair(root, 0)); while (!q.isEmpty()) { NodePosPair npp = q.poll(); - npp.placeIntoMap(xPosMap); + npp.placeIntoMap(columnTable); npp.queueChildren(q); } - List> columnsAtXPos = new ArrayList<>(xPosMap.values()); - - columnsAtXPos.addAll(xPosMap.values()); + List> columnsAtXPos = new ArrayList<>(columnTable.values()); return columnsAtXPos; } @@ -38,9 +36,9 @@ private class NodePosPair { final TreeNode node; final int x; - void placeIntoMap(TreeMap> xPosMap) { - xPosMap.putIfAbsent(x, new ArrayList<>()); - xPosMap.get(x).add(node.val); + void placeIntoMap(TreeMap> columnTable) { + columnTable.putIfAbsent(x, new ArrayList<>()); + columnTable.get(x).add(node.val); } void queueChildren(Deque q) { diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java index a87e8fc0..7747e94c 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java @@ -13,46 +13,47 @@ public class BinaryTreeVerticalOrderTraversalDFS { int minColumn = 0, maxColumn = 0; public List> verticalOrder(TreeNode root) { + if (root == null) { return Collections.emptyList(); } - + DFS(root, 0, 0); - - List> output = new ArrayList<>(); - // Retrieve the resuts, by ordering by column and sorting by row - for (int i = minColumn; i < maxColumn + 1; ++i) { + List> columnsAtXPos = new ArrayList<>(); - Collections.sort(columnTable.get(i), (p1,p2) -> p1[0] - p2[0]); + for (int i = minColumn; i <= maxColumn; i++) { + + Collections.sort(columnTable.get(i), (p1, p2) -> p1[0] - p2[0]); List sortedColumn = new ArrayList<>(); - for (int[] p : columnTable.get(i)) { - sortedColumn.add(p[1]); + + for (int[] rowValPair : columnTable.get(i)) { + sortedColumn.add(rowValPair[1]); } - output.add(sortedColumn); + + columnsAtXPos.add(sortedColumn); } - return output; + return columnsAtXPos; } - private void DFS(TreeNode root, Integer row, Integer col) { - - if (root == null){ + private void DFS(TreeNode root, int row, int col) { + + if (root == null) { return; } columnTable.putIfAbsent(col, new ArrayList<>()); - columnTable.get(col).add(new int[]{row, root.val}); + columnTable.get(col).add(new int[] { row, root.val }); minColumn = Math.min(minColumn, col); maxColumn = Math.max(maxColumn, col); - // preorder DFS traversal + DFS(root.left, row + 1, col - 1); DFS(root.right, row + 1, col + 1); } - public static void main(String[] args) { var solution = new BinaryTreeVerticalOrderTraversalDFS(); From 588326b3fde1e02b34017bc7accce1f0bd85b94d Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 12:04:10 +0300 Subject: [PATCH 07/12] 314-Utilize Tree Range --- .../BinaryTreeVerticalOrderTraversalDFS.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java index 7747e94c..3901e10f 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalDFS.java @@ -20,7 +20,7 @@ public List> verticalOrder(TreeNode root) { DFS(root, 0, 0); - List> columnsAtXPos = new ArrayList<>(); + List> columnsAtXPos = new ArrayList<>(maxColumn - minColumn + 2); for (int i = minColumn; i <= maxColumn; i++) { From 70fa33bca7413fbaed5881768a777b38bc006b2e Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 13:08:19 +0300 Subject: [PATCH 08/12] 314-Fix Class Name --- ...ode.java => BinaryTreeVerticalOrderTraversalBFSTreeMap.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/{BinaryTreeVerticalOrderTraversalBFSTreeNode.java => BinaryTreeVerticalOrderTraversalBFSTreeMap.java} (96%) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java similarity index 96% rename from src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java rename to src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java index fbdd664e..34f021d1 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeNode.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java @@ -9,7 +9,7 @@ import algorithms.datastructures.TreeNode; -public class BinaryTreeVerticalOrderTraversalBFSTreeNode { +public class BinaryTreeVerticalOrderTraversalBFSTreeMap { public List> verticalOrder(TreeNode root) { if (root == null) { From ef8d1a104fe36f6b4c2141866e189f32f80ca57d Mon Sep 17 00:00:00 2001 From: ErdemT09 Date: Sun, 13 Jun 2021 13:15:18 +0300 Subject: [PATCH 09/12] 314-Change Variable Access Modifier --- .../BinaryTreeVerticalOrderTraversalBFS.java | 4 ++-- .../BinaryTreeVerticalOrderTraversalBFSTreeMap.java | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index 2648d15c..a0f253ed 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -54,8 +54,8 @@ public void getRange(TreeNode root, int[] range, int col) { } private class NodePosPair { - final TreeNode node; - final int x; + private final TreeNode node; + private final int x; void placeIntoMap(List> columnTable) { columnTable.get(x).add(node.val); diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java index 34f021d1..9fe9f9a2 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFSTreeMap.java @@ -33,8 +33,8 @@ public List> verticalOrder(TreeNode root) { } private class NodePosPair { - final TreeNode node; - final int x; + private final TreeNode node; + private final int x; void placeIntoMap(TreeMap> columnTable) { columnTable.putIfAbsent(x, new ArrayList<>()); @@ -57,7 +57,7 @@ void queueChildren(Deque q) { } public static void main(String[] args) { - var solution = new BinaryTreeVerticalOrderTraversalBFSTreeNode(); + var solution = new BinaryTreeVerticalOrderTraversalBFSTreeMap(); TreeNode tn1 = new TreeNode(1); TreeNode t0 = new TreeNode(2, null, tn1); From fdd0cf3b35625633dee716ceda1e9b3dce8cb0e2 Mon Sep 17 00:00:00 2001 From: ErdemT09 <63192680+ErdemT09@users.noreply.github.com> Date: Sun, 13 Jun 2021 16:06:18 +0300 Subject: [PATCH 10/12] 314-Remove Variable 1 Co-authored-by: altayhunoglu <60903744+altayhunoglu@users.noreply.github.com> --- .../BinaryTreeVerticalOrderTraversalBFS.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index a0f253ed..71f6b055 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -17,7 +17,7 @@ public List> verticalOrder(TreeNode root) { return Collections.emptyList(); } - nodeCount = 0; + int[] range = new int[] {0, 0}; getRange(root, range, 0); From 8a43d699382fb43ce831013e0818f38db7d592c5 Mon Sep 17 00:00:00 2001 From: ErdemT09 <63192680+ErdemT09@users.noreply.github.com> Date: Sun, 13 Jun 2021 16:06:24 +0300 Subject: [PATCH 11/12] 314-Remove Variable 2 Co-authored-by: altayhunoglu <60903744+altayhunoglu@users.noreply.github.com> --- .../BinaryTreeVerticalOrderTraversalBFS.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index 71f6b055..5ec0c27e 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -11,7 +11,6 @@ public class BinaryTreeVerticalOrderTraversalBFS { - int nodeCount; public List> verticalOrder(TreeNode root) { if (root == null) { return Collections.emptyList(); From 94e0174b4f3e8a5b8108d6634c271663951c9a10 Mon Sep 17 00:00:00 2001 From: ErdemT09 <63192680+ErdemT09@users.noreply.github.com> Date: Sun, 13 Jun 2021 16:06:31 +0300 Subject: [PATCH 12/12] 314-Remove Variable 3 Co-authored-by: altayhunoglu <60903744+altayhunoglu@users.noreply.github.com> --- .../BinaryTreeVerticalOrderTraversalBFS.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java index 5ec0c27e..71480e76 100644 --- a/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java +++ b/src/main/java/algorithms/curated170/medium/binarytreeverticalordertraversal/BinaryTreeVerticalOrderTraversalBFS.java @@ -44,7 +44,7 @@ public void getRange(TreeNode root, int[] range, int col) { return; } - nodeCount++; + range[0] = Math.min(range[0], col); range[1] = Math.max(range[1], col);