diff --git a/binary-tree-maximum-path-sum/TonyKim9401.java b/binary-tree-maximum-path-sum/TonyKim9401.java new file mode 100644 index 000000000..db69e7a05 --- /dev/null +++ b/binary-tree-maximum-path-sum/TonyKim9401.java @@ -0,0 +1,24 @@ +// TC: O(n) +// visit all nodes to find maximum path +// SC: O(h) +// h means the high of binary tree +class Solution { + private int output = Integer.MIN_VALUE; + public int maxPathSum(TreeNode root) { + max(root); + return output; + } + + private int max(TreeNode node) { + if (node == null) return 0; + + int leftSum = Math.max(max(node.left), 0); + int rightSum = Math.max(max(node.right), 0); + + int currentMax = node.val + leftSum + rightSum; + + output = Math.max(output, currentMax); + + return node.val + Math.max(leftSum, rightSum); + } +} diff --git a/graph-valid-tree/TonyKim9401.java b/graph-valid-tree/TonyKim9401.java new file mode 100644 index 000000000..aaaf354cd --- /dev/null +++ b/graph-valid-tree/TonyKim9401.java @@ -0,0 +1,37 @@ +// TC: O(n * m) +// n = the length of edges, m = the length of each element list of edges +// SC: O(n) +// n = recursively visit everywhere +public class Solution { + public boolean validTree(int n, int[][] edges) { + if (edges.length != n - 1) return false; + + List> graph = new ArrayList<>(); + for (int i = 0; i < n; i++) { + graph.add(new ArrayList<>()); + } + + for (int[] edge : edges) { + graph.get(edge[0]).add(edge[1]); + graph.get(edge[1]).add(edge[0]); + } + + boolean[] visited = new boolean[n]; + if (!dfs(0, -1, graph, visited)) return false; + + for (boolean v : visited) if(!v) return false; + + return true; + } + + private boolean dfs(int node, int parent, List> graph, boolean[] visited) { + visited[node] = true; + + for (int neighbor : graph.get(node)) { + if (neighbor == parent) continue; + if (visited[neighbor]) return false; + if (!dfs(neighbor, node, graph, visited)) return false; + } + return true; + } +} diff --git a/insert-interval/TonyKim9401.java b/insert-interval/TonyKim9401.java new file mode 100644 index 000000000..aa13d3513 --- /dev/null +++ b/insert-interval/TonyKim9401.java @@ -0,0 +1,32 @@ +// TC: O(n) +// must retrieve all elements +// SC: O(n) +// need the same size of memory space in the worst case +class Solution { + public int[][] insert(int[][] intervals, int[] newInterval) { + List output = new ArrayList<>(); + + int i = 0; + int n = intervals.length; + + while (i < n && intervals[i][1] < newInterval[0]) { + output.add(intervals[i]); + i += 1; + } + + while (i < n && intervals[i][0] <= newInterval[1]) { + newInterval[0] = Math.min(newInterval[0], intervals[i][0]); + newInterval[1] = Math.max(newInterval[1], intervals[i][1]); + i += 1; + } + + output.add(newInterval); + + while (i < n) { + output.add(intervals[i]); + i += 1; + } + + return output.toArray(new int[output.size()][]); + } +} diff --git a/maximum-depth-of-binary-tree/TonyKim9401.java b/maximum-depth-of-binary-tree/TonyKim9401.java new file mode 100644 index 000000000..257b51ae5 --- /dev/null +++ b/maximum-depth-of-binary-tree/TonyKim9401.java @@ -0,0 +1,15 @@ +// TC: O(n) +// visiting all nodes +// SC: O(1) +// constant space complexity +class Solution { + public int maxDepth(TreeNode root) { + return getMax(root, 0); + } + + private int getMax(TreeNode node, int depth) { + if (node == null) return depth; + depth += 1; + return Math.max(getMax(node.left, depth), getMax(node.right, depth)); + } +} diff --git a/reorder-list/TonyKim9401.java b/reorder-list/TonyKim9401.java new file mode 100644 index 000000000..47fc8e4b2 --- /dev/null +++ b/reorder-list/TonyKim9401.java @@ -0,0 +1,34 @@ +// TC: O(n) +// -> find middle, reverse, merge -> max O(n) +// SC: O(1) +class Solution { + public void reorderList(ListNode head) { + if (head == null || head.next == null) return; + + ListNode slow = head, fast = head; + while (fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + } + + ListNode backSide = null; + ListNode curr = slow.next; + slow.next = null; + + while (curr != null) { + ListNode temp = curr.next; + curr.next = backSide; + backSide = curr; + curr = temp; + } + + ListNode first = head; + ListNode second = backSide; + while (second != null) { + ListNode temp = first.next; + first.next = second; + first = second; + second = temp; + } + } +}