From 1e71b312f80855f1836f40c95d3699c5c05db213 Mon Sep 17 00:00:00 2001 From: Ritika Ranjan <69729892+Rranjan04@users.noreply.github.com> Date: Sun, 3 Oct 2021 13:46:51 +0530 Subject: [PATCH] Added code for inportant questions on Trees --- Trees/AllKSumPath.java | 48 ++++++++++++ Trees/BST/BST.java | 21 +++++ Trees/BST/BSTNode.java | 14 ++++ Trees/BSTFromLevelOrder.java | 18 +++++ Trees/BSTFromPostOrder.java | 24 ++++++ Trees/BSTFromPreOrder.java | 22 ++++++ Trees/BSTtoGST.java | 17 ++++ Trees/BTFromLevelOrderAndInOrder.java | 25 ++++++ Trees/BTFromPostOrderAndInOrder.java | 26 ++++++ Trees/BTFromPreOrderAndInOrder.java | 28 +++++++ Trees/BTFromPreOrderAndPostOrder.java | 22 ++++++ Trees/BinaryTree/BinaryTree.java | 30 +++++++ Trees/BinaryTree/TreeNode.java | 11 +++ Trees/BinaryTreeToCircularDLL.java | 47 +++++++++++ Trees/BottomView.java | 46 +++++++++++ Trees/BurnATree.java | 68 ++++++++++++++++ Trees/CameraInBT.java | 30 +++++++ Trees/CloneTreeWithARandomPointer.java | 40 ++++++++++ Trees/ColoringGame.java | 34 ++++++++ Trees/DLLToBST.java | 72 +++++++++++++++++ Trees/DeleteNodesWithAGivenValue.java | 12 +++ Trees/DesignALeaderBoard.java | 50 ++++++++++++ Trees/DiagonalOrder.java | 48 ++++++++++++ Trees/DiagonalOrderII.java | 47 +++++++++++ Trees/DiameterII.java | 16 ++++ Trees/DiameterOfNaryTree.java | 41 ++++++++++ Trees/DiameterOfTree.java | 22 ++++++ Trees/DistributeCoins.java | 29 +++++++ Trees/FlattenABST.java | 26 ++++++ Trees/HasPathSum.java | 14 ++++ Trees/HouseRobber.java | 30 +++++++ Trees/ImageMultiplication.java | 26 ++++++ Trees/KDistanceAway.java | 55 +++++++++++++ Trees/KthSmallestInteger.java | 23 ++++++ Trees/LCA.java | 17 ++++ Trees/LCAOfBST.java | 23 ++++++ Trees/LeastRecentlyUsedCache.java | 72 +++++++++++++++++ Trees/LeftView.java | 39 +++++++++ Trees/LongestZigZagPath.java | 34 ++++++++ Trees/LongestZigZagPathII.java | 23 ++++++ Trees/MaxDiffBwNodeAndAncestors.java | 18 +++++ Trees/MaxPathBwAnyNodes.java | 24 ++++++ Trees/MaxPathSum.java | 20 +++++ Trees/MaxProductSplittedBinaryTree.java | 31 ++++++++ Trees/Merge2BST.java | 77 ++++++++++++++++++ Trees/Merge2BSTOptimal.java | 100 ++++++++++++++++++++++++ Trees/MinDistBwNodes.java | 61 +++++++++++++++ Trees/PathSumII.java | 34 ++++++++ Trees/PathSumIII.java | 21 +++++ Trees/PathSumIIOptimum.java | 31 ++++++++ Trees/PopulatingNextRightPointers.java | 29 +++++++ Trees/RecoverBST.java | 43 ++++++++++ Trees/RecoverBSTII.java | 26 ++++++ Trees/ReverseLevelOrder.java | 39 +++++++++ Trees/RightView.java | 41 ++++++++++ Trees/SerializeAndDeserialize.java | 45 +++++++++++ Trees/SumOfDistancesInTree.java | 7 ++ Trees/SumRootToLeaf.java | 30 +++++++ Trees/TopView.java | 45 +++++++++++ Trees/TweetCountPerFreq.java | 36 +++++++++ Trees/ValidateBST.java | 35 +++++++++ Trees/ValidateBSTII.java | 21 +++++ Trees/VerticalOrder.java | 63 +++++++++++++++ Trees/VerticalOrderSum.java | 64 +++++++++++++++ Trees/WidthOfABinaryTree.java | 47 +++++++++++ 65 files changed, 2278 insertions(+) create mode 100644 Trees/AllKSumPath.java create mode 100644 Trees/BST/BST.java create mode 100644 Trees/BST/BSTNode.java create mode 100644 Trees/BSTFromLevelOrder.java create mode 100644 Trees/BSTFromPostOrder.java create mode 100644 Trees/BSTFromPreOrder.java create mode 100644 Trees/BSTtoGST.java create mode 100644 Trees/BTFromLevelOrderAndInOrder.java create mode 100644 Trees/BTFromPostOrderAndInOrder.java create mode 100644 Trees/BTFromPreOrderAndInOrder.java create mode 100644 Trees/BTFromPreOrderAndPostOrder.java create mode 100644 Trees/BinaryTree/BinaryTree.java create mode 100644 Trees/BinaryTree/TreeNode.java create mode 100644 Trees/BinaryTreeToCircularDLL.java create mode 100644 Trees/BottomView.java create mode 100644 Trees/BurnATree.java create mode 100644 Trees/CameraInBT.java create mode 100644 Trees/CloneTreeWithARandomPointer.java create mode 100644 Trees/ColoringGame.java create mode 100644 Trees/DLLToBST.java create mode 100644 Trees/DeleteNodesWithAGivenValue.java create mode 100644 Trees/DesignALeaderBoard.java create mode 100644 Trees/DiagonalOrder.java create mode 100644 Trees/DiagonalOrderII.java create mode 100644 Trees/DiameterII.java create mode 100644 Trees/DiameterOfNaryTree.java create mode 100644 Trees/DiameterOfTree.java create mode 100644 Trees/DistributeCoins.java create mode 100644 Trees/FlattenABST.java create mode 100644 Trees/HasPathSum.java create mode 100644 Trees/HouseRobber.java create mode 100644 Trees/ImageMultiplication.java create mode 100644 Trees/KDistanceAway.java create mode 100644 Trees/KthSmallestInteger.java create mode 100644 Trees/LCA.java create mode 100644 Trees/LCAOfBST.java create mode 100644 Trees/LeastRecentlyUsedCache.java create mode 100644 Trees/LeftView.java create mode 100644 Trees/LongestZigZagPath.java create mode 100644 Trees/LongestZigZagPathII.java create mode 100644 Trees/MaxDiffBwNodeAndAncestors.java create mode 100644 Trees/MaxPathBwAnyNodes.java create mode 100644 Trees/MaxPathSum.java create mode 100644 Trees/MaxProductSplittedBinaryTree.java create mode 100644 Trees/Merge2BST.java create mode 100644 Trees/Merge2BSTOptimal.java create mode 100644 Trees/MinDistBwNodes.java create mode 100644 Trees/PathSumII.java create mode 100644 Trees/PathSumIII.java create mode 100644 Trees/PathSumIIOptimum.java create mode 100644 Trees/PopulatingNextRightPointers.java create mode 100644 Trees/RecoverBST.java create mode 100644 Trees/RecoverBSTII.java create mode 100644 Trees/ReverseLevelOrder.java create mode 100644 Trees/RightView.java create mode 100644 Trees/SerializeAndDeserialize.java create mode 100644 Trees/SumOfDistancesInTree.java create mode 100644 Trees/SumRootToLeaf.java create mode 100644 Trees/TopView.java create mode 100644 Trees/TweetCountPerFreq.java create mode 100644 Trees/ValidateBST.java create mode 100644 Trees/ValidateBSTII.java create mode 100644 Trees/VerticalOrder.java create mode 100644 Trees/VerticalOrderSum.java create mode 100644 Trees/WidthOfABinaryTree.java diff --git a/Trees/AllKSumPath.java b/Trees/AllKSumPath.java new file mode 100644 index 0000000..bbca221 --- /dev/null +++ b/Trees/AllKSumPath.java @@ -0,0 +1,48 @@ +package Trees; + +import java.util.ArrayList; + +import Trees.BinaryTree.*; +public class AllKSumPath { + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.root = new TreeNode(1); + tree.root.left = new TreeNode(3); + tree.root.left.left = new TreeNode(2); + tree.root.left.right = new TreeNode(1); + tree.root.left.right.left = new TreeNode(1); + tree.root.right = new TreeNode(-1); + tree.root.right.left = new TreeNode(4); + tree.root.right.left.left = new TreeNode(1); + tree.root.right.left.right = new TreeNode(2); + tree.root.right.right = new TreeNode(5); + tree.root.right.right.right = new TreeNode(2); + int k = 5; + findK(tree.root, k); + } + static void findK(TreeNode root, int k){ + if(root==null) return; + ArrayList path = new ArrayList<>(); + findkHelp(root, path, k); + } + static void findkHelp(TreeNode root, ArrayList path, int k){ + if(root==null) return; + path.add(root.val); + findkHelp(root.left, path, k); + findkHelp(root.right, path, k); + int f = 0; + //check at every node + for(int j=path.size()-1;j>=0;j--){ + f+=path.get(j); + if(f==k) printk(path, j); + } + // backtraking + path.remove(path.size()-1); + } + static void printk(ArrayList arr,int j){ + for(int i=j;iarr.length-1) return null; + TreeNode root = new TreeNode(arr[start]); + root.left = build(arr, 2*start+1); + root.right = build(arr, 2*start+2); + return root; + } +} diff --git a/Trees/BSTFromPostOrder.java b/Trees/BSTFromPostOrder.java new file mode 100644 index 0000000..493a215 --- /dev/null +++ b/Trees/BSTFromPostOrder.java @@ -0,0 +1,24 @@ +package Trees; + +import Trees.BinaryTree.*; +public class BSTFromPostOrder { + public static void main(String[] args) { + int[] p = {1, 7, 5, 50, 40, 10}; + BinaryTree tree = new BinaryTree(); + tree.root = build(p, 0, p.length-1); + BinaryTree.display(tree.root); + } + static TreeNode build(int[] post, int start, int end){ + if(start>end) return null; + TreeNode root = new TreeNode(post[end]); + if(start==end) return root; + int idx = start; + while(post[end]>post[idx]){ + idx++; + } + int k = idx-start; + root.left = build(post, start, start+k-1); + root.right = build(post, start+k, end-1); + return root; + } +} diff --git a/Trees/BSTFromPreOrder.java b/Trees/BSTFromPreOrder.java new file mode 100644 index 0000000..2a29ac1 --- /dev/null +++ b/Trees/BSTFromPreOrder.java @@ -0,0 +1,22 @@ +package Trees; + +import Trees.BinaryTree.*; +public class BSTFromPreOrder { + public TreeNode bstFromPreorder(int[] pre) { + return help(pre,0,pre.length-1); + } + static TreeNode help(int[] pre, int start, int end){ + if(start>end) return null; + TreeNode root = new TreeNode(pre[start]); + if(start==end) return root; + int idx = start; + while(idx< pre.length && pre[start]>=pre[idx]){ + idx++; + } + int k = idx-start; + root.left = help(pre,start+1,start+k-1); + root.right = help(pre,start+k,end); + return root; + + } +} diff --git a/Trees/BSTtoGST.java b/Trees/BSTtoGST.java new file mode 100644 index 0000000..a0e06f9 --- /dev/null +++ b/Trees/BSTtoGST.java @@ -0,0 +1,17 @@ +package Trees; + +import Trees.BinaryTree.*; +public class BSTtoGST { + int sum = 0; + public TreeNode bstToGst(TreeNode root){ + if(root==null){ + return null; + } + bstToGst(root.right); + root.val +=sum; + sum = root.val; + bstToGst(root.left); + return root; + } + +} diff --git a/Trees/BTFromLevelOrderAndInOrder.java b/Trees/BTFromLevelOrderAndInOrder.java new file mode 100644 index 0000000..f57dfd8 --- /dev/null +++ b/Trees/BTFromLevelOrderAndInOrder.java @@ -0,0 +1,25 @@ +package Trees; + +import Trees.BinaryTree.*; +public class BTFromLevelOrderAndInOrder { + public static void main(String[] args) { + int[] in = { 4, 2, 5, 1, 6, 3, 7 }; + int[] lo = { 1, 2, 3, 4, 5, 6, 7 }; + BinaryTree tree = new BinaryTree(); + tree.root = build(in, 0, in.length-1, lo, 0, lo.length-1); + BinaryTree.display(tree.root); + } + static TreeNode build(int[] in, int inStart, int inEnd, int[] level, int lStart, int lEnd){ + if(inStart>inEnd||lStart>level.length-1)return null; + TreeNode root = new TreeNode(level[lStart]); + if(inStart==inEnd) return root; + int idx = inStart; + while(level[lStart]!=in[idx]){ + idx++; + } + int k = idx-inStart; + root.left = build(in, inStart, inStart+k-1, level, 2*lStart+1, lEnd); + root.right = build(in, inStart+k+1, inEnd, level, 2*lStart+2, lEnd); + return root; + } +} diff --git a/Trees/BTFromPostOrderAndInOrder.java b/Trees/BTFromPostOrderAndInOrder.java new file mode 100644 index 0000000..898d7a7 --- /dev/null +++ b/Trees/BTFromPostOrderAndInOrder.java @@ -0,0 +1,26 @@ +package Trees; + +import Trees.BinaryTree.*; +public class BTFromPostOrderAndInOrder { + public static void main(String[] args) { + int[] pre = {9,15,7,20,3}; + int[] in = {9,3,15,20,7}; + BinaryTree tree = new BinaryTree(); + tree.root = build(in, pre, 0, in.length-1,0, pre.length-1); + BinaryTree.display(tree.root); + } + static TreeNode build(int[] in, int[] post, int inStart, int inEnd,int pStart,int pEnd){ + if(pStart>pEnd || inStart>inEnd) return null; + TreeNode root = new TreeNode(post[pEnd]); + int i = find(in, inStart, inEnd, post[pEnd]); + root.left = build(in, post, inStart, i-1, pStart,pStart+i-inStart-1); + root.right = build(in, post, i+1, inEnd, pStart+i -inStart,pEnd-1); + return root; + } + static int find(int[] in, int inStart, int inEnd,int ele){ + for(int i=inStart;i<=inEnd;i++){ + if(in[i]==ele) return i; + } + return -1; + } +} diff --git a/Trees/BTFromPreOrderAndInOrder.java b/Trees/BTFromPreOrderAndInOrder.java new file mode 100644 index 0000000..6f77abd --- /dev/null +++ b/Trees/BTFromPreOrderAndInOrder.java @@ -0,0 +1,28 @@ +package Trees; + +import Trees.BinaryTree.BinaryTree; +import Trees.BinaryTree.TreeNode; + +public class BTFromPreOrderAndInOrder { + public static void main(String[] args) { + int[] pre = {3,9,20,15,7}; + int[] in = {9,3,15,20,7}; + BinaryTree tree = new BinaryTree(); + tree.root = build(in, pre, 0, in.length-1, 0,pre.length-1); + BinaryTree.display(tree.root); + } + static TreeNode build(int[] in, int[] pre, int inStart, int inEnd ,int pStart,int pEnd){ + if(inStart>inEnd) return null; + TreeNode root = new TreeNode(pre[pStart]); + int i = find(in, inStart, inEnd,pre[pStart]); + root.left = build(in, pre, inStart, i-1, pStart+1,pEnd+(i-inStart)); + root.right = build(in, pre, i+1, inEnd, pStart+(i-inStart)+1,pEnd); + return root; + } + static int find(int[] in, int inStart, int inEnd,int ele){ + for(int i=inStart;i<=inEnd;i++){ + if(in[i]==ele) return i; + } + return -1; + } +} diff --git a/Trees/BTFromPreOrderAndPostOrder.java b/Trees/BTFromPreOrderAndPostOrder.java new file mode 100644 index 0000000..1fa7920 --- /dev/null +++ b/Trees/BTFromPreOrderAndPostOrder.java @@ -0,0 +1,22 @@ +package Trees; + +import Trees.BinaryTree.*; +public class BTFromPreOrderAndPostOrder { + public TreeNode constructFromPrePost(int[] pre, int[] post) { + return help(pre,post,0,pre.length-1,0,post.length-1); + } + public TreeNode help(int[] pre, int[] post, int s1, int e1, int s2, int e2){ + if(s1>e1) return null; + TreeNode root = new TreeNode(pre[s1]); + if(s1==e1) return root; + int idx = s2; + while(post[idx]!=pre[s1+1]){ + idx++; + } + int k = idx-s2+1; + root.left = help(pre,post,s1+1,s1+k,s2,idx); + root.right = help(pre,post,s1+k+1,e1,idx+1,e2-1); + return root; + + } +} diff --git a/Trees/BinaryTree/BinaryTree.java b/Trees/BinaryTree/BinaryTree.java new file mode 100644 index 0000000..dd4799c --- /dev/null +++ b/Trees/BinaryTree/BinaryTree.java @@ -0,0 +1,30 @@ +package Trees.BinaryTree; + + +public class BinaryTree { + public TreeNode root; + public TreeNode create(int[] arr){ + if(arr.length==0) return null; + root = new TreeNode(arr[0]); + return insert(arr, root, 0); + } + private TreeNode insert(int[] arr,TreeNode root, int i){ + // level-wise + if(i bottom(TreeNode root){ + List ans = new ArrayList<>(); + if(root==null) return ans; + Map map = new HashMap<>(); + Queue queue = new LinkedList<>(); + queue.add(new Point(0, 0, root)); + int minIndex = Integer.MAX_VALUE; + int maxIndex = Integer.MIN_VALUE; + while(!queue.isEmpty()){ + Point p = queue.poll(); + map.put(p.x, p.root.val); + minIndex = Math.min(minIndex,p.x); + maxIndex = Math.max(maxIndex,p.x); + if(p.root.left!=null) queue.add(new Point(p.x-1, p.y+1, p.root.left)); + if(p.root.right!=null) queue.add(new Point(p.x+1, p.y+1, p.root.right)); + } + for(int i=minIndex;i<=maxIndex;i++){ + ans.add(map.get(i)); + } + return ans; + + + } + +} diff --git a/Trees/BurnATree.java b/Trees/BurnATree.java new file mode 100644 index 0000000..839bba5 --- /dev/null +++ b/Trees/BurnATree.java @@ -0,0 +1,68 @@ +package Trees; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.Queue; + +import Trees.BinaryTree.*; +public class BurnATree { + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.root = new TreeNode(12); + tree.root.left = new TreeNode(13); + tree.root.right = new TreeNode(10); + tree.root.right.left = new TreeNode(14); + tree.root.right.right = new TreeNode(15); + tree.root.right.left.left = new TreeNode(21); + tree.root.right.left.right = new TreeNode(24); + tree.root.right.right.left = new TreeNode(22); + tree.root.right.right.right = new TreeNode(23); + TreeNode node = find(tree.root, 14); + find(tree.root, node); + } + static TreeNode find(TreeNode root, int data){ + if(root==null) return null; + if(root.val == data) return root; + TreeNode l = find(root.left, data); + TreeNode r = find(root.right, data); + return l==null?r:l; + } + static void find(TreeNode root, TreeNode node){ + if(root==null) return; + HashMap map = new HashMap<>(); + findParent(map, root); + HashSet set = new HashSet<>(); + Queue q = new LinkedList<>(); + q.add(node); + q.add(null); + while(!q.isEmpty()){ + TreeNode n = q.poll(); + if(n==null){ + System.out.println(); + if(!q.isEmpty()) q.add(null); + } + else{ + System.out.print(n.val+" "); + set.add(n); + if(n.left!=null && !set.contains(n.left)){ + q.add(n.left); + } + if(n.right!=null && !set.contains(n.right)){ + q.add(n.right); + } + if(map.containsKey(n) && !set.contains(map.get(n))){ + q.add(map.get(n)); + } + } + } + } + static void findParent(HashMap map,TreeNode root){ + if(root==null) return; + if(root.left!=null) map.put(root.left, root); + if(root.right!=null) map.put(root.right, root); + findParent(map, root.left); + findParent(map, root.right); + + } +} diff --git a/Trees/CameraInBT.java b/Trees/CameraInBT.java new file mode 100644 index 0000000..69a52fa --- /dev/null +++ b/Trees/CameraInBT.java @@ -0,0 +1,30 @@ +package Trees; + +import Trees.BinaryTree.*; +public class CameraInBT { + public static void main(String[] args) { + + } + static int camera = 0; + static int camera(TreeNode root){ + if(help(root)==-1) camera++; + return camera; + } + // 0 -> has camera + // 1-> is Covered + // -1-> needs to be covered + static int help(TreeNode root){ + if(root==null) return 1; + int l = help(root.left); + int r = help(root.right); + if(l==-1||r==-1){ + camera++; + return 0; + } + if(l==0||r==0){ + return 1; + } + return -1; + } + +} diff --git a/Trees/CloneTreeWithARandomPointer.java b/Trees/CloneTreeWithARandomPointer.java new file mode 100644 index 0000000..6523fcc --- /dev/null +++ b/Trees/CloneTreeWithARandomPointer.java @@ -0,0 +1,40 @@ +package Trees; + +import java.util.HashMap; + +class Node{ + int key; + Node left; + Node right; + Node random; + Node(int key){ + this.key = key; + left = right = random = null; + } +} +public class CloneTreeWithARandomPointer { + public static void main(String[] args) { + + } + static Node cloneTree(Node root){ + HashMap map = new HashMap<>(); + Node cloneNode = cloneLR(root, map); + cloneRandom(root, cloneNode, map); + return cloneNode; + } + static Node cloneLR(Node node, HashMap map){ + if(node==null) return null; + Node cloneNode = new Node(node.key); + map.put(node, cloneNode); + cloneNode.left = cloneLR(node.left,map); + cloneNode.right = cloneLR(node.right,map); + return cloneNode; + + } + static void cloneRandom(Node node, Node cloneNode, HashMap map){ + if(node==null) return; + cloneNode.random = map.get(node).random; + cloneRandom(node.left, cloneNode.left, map); + cloneRandom(node.right,cloneNode.right,map); + } +} diff --git a/Trees/ColoringGame.java b/Trees/ColoringGame.java new file mode 100644 index 0000000..868f96a --- /dev/null +++ b/Trees/ColoringGame.java @@ -0,0 +1,34 @@ +package Trees; + +import Trees.BinaryTree.*; +public class ColoringGame { + class Solution { + public boolean btreeGameWinningMove(TreeNode root, int n, int x) { + //Basic intution : whoever colors more than n/2 nodes wins + TreeNode node = find(root,x);// find node in the tree + /* + 3 cases to choose the node from + Left subtree + Right subtree + Above the current node; + */ + int lc = count(node.left); + int rc = count(node.right); + return Math.max(n-lc-rc-1,Math.max(lc,rc))>n/2; + + } + public TreeNode find(TreeNode root , int x){ + if(root==null) return null; + if(root.val==x) return root; + TreeNode l = find(root.left,x); + TreeNode r = find(root.right,x); + return l==null?r:l; + } + public int count(TreeNode root){ + if(root==null) return 0; + int l = count(root.left); + int r = count(root.right); + return l+r+1; + } + } +} diff --git a/Trees/DLLToBST.java b/Trees/DLLToBST.java new file mode 100644 index 0000000..d9784f3 --- /dev/null +++ b/Trees/DLLToBST.java @@ -0,0 +1,72 @@ +package Trees; + +public class DLLToBST { + static class Node{ + int data; + Node prev; + Node next; + Node(int data){ + this.data = data; + next = prev = null; + } + } + static class DLL{ + public Node head = null; + public Node prev = null; + public void insert(int data){ + Node node = new Node(data); + if(prev==null){ + head = node; + }else{ + prev.next = node; + node.prev = prev; + } + prev = node; + } + } + public static void main(String[] args) { + DLL ll = new DLL(); + ll.insert(1); + ll.insert(2); + ll.insert(3); + ll.head = convert(ll.head); + display(ll.head); + } + + static void display(Node root){ + if(root.prev==null) return; + String str = root.data+" L: "; + str+=root.prev==null?"null":root.prev.data+""; + str+=" R: "; + str+=root.next==null?"null":root.next.data+""; + System.out.println(str); + display(root.prev); + display(root.next); + + } + static Node convert(Node root){ + if(root==null||(root.next==null&&root.prev==null)) return root; + Node mid = mid(root); + Node temp = mid.next; + if(mid.prev!=null){ + mid.prev.next=null; + } + mid.prev = null; + if(mid.next!=null){ + mid.next.prev = null; + } + mid.next = null; + mid.prev = convert(root); + mid.next = convert(temp); + return mid; + } + static Node mid(Node node){ + Node slow = node; + Node fast = node; + while(fast.next!=null && fast.next.next!=null){ + fast = fast.next.next; + slow = slow.next; + } + return slow; + } +} \ No newline at end of file diff --git a/Trees/DeleteNodesWithAGivenValue.java b/Trees/DeleteNodesWithAGivenValue.java new file mode 100644 index 0000000..9ebad16 --- /dev/null +++ b/Trees/DeleteNodesWithAGivenValue.java @@ -0,0 +1,12 @@ +package Trees; + +import Trees.BinaryTree.*; +public class DeleteNodesWithAGivenValue { + public TreeNode removeLeafNodes(TreeNode root, int target) { + if(root==null) return null; + root.left = removeLeafNodes(root.left, target); + root.right = removeLeafNodes(root.right,target); + if(root.val==target && root.left==null && root.right==null) return null; + return root; + } +} diff --git a/Trees/DesignALeaderBoard.java b/Trees/DesignALeaderBoard.java new file mode 100644 index 0000000..be16f3a --- /dev/null +++ b/Trees/DesignALeaderBoard.java @@ -0,0 +1,50 @@ +package Trees; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.PriorityQueue; + +public class DesignALeaderBoard { + Map map; + PriorityQueue pq; + class Player implements Comparable{ + int id; + int score; + Player(int id, int score){ + this.id = id; + this.score = score; + } + public int compareTo(Player p){ + return Integer.compare(p.score, this.score); + } + } + public DesignALeaderBoard() { + map = new HashMap<>(); + pq = new PriorityQueue<>(Collections.reverseOrder()); + } + public void addScore(int playerId, int score) { + map.putIfAbsent(playerId, 0); + map.put(playerId, score); + pq.offer(new Player(playerId, score)); + } + public int top(int k) { + ArrayList temp = new ArrayList<>(); + int ans = 0; + for(int i=0;i> ans = travel(root); + for(List l:ans){ + System.out.println(l); + } + } + static List> travel(TreeNode root){ + List> list = new ArrayList<>(); + if(root==null) return list; + LinkedList q = new LinkedList<>(); + q.addLast(root); + while(!q.isEmpty()){ + int size = q.size(); + List l = new ArrayList<>(); + while(size>0){ + TreeNode node = q.poll(); + while(node!=null){ + l.add(node.val); + if(node.left!=null){ + q.addLast(node.left); + } + node = node.right; + } + size-=1; + } + + list.add(l); + } + return list; + } +} diff --git a/Trees/DiagonalOrderII.java b/Trees/DiagonalOrderII.java new file mode 100644 index 0000000..d77747c --- /dev/null +++ b/Trees/DiagonalOrderII.java @@ -0,0 +1,47 @@ +package Trees; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +import Trees.BinaryTree.*; +public class DiagonalOrderII { + public static void main(String[] args) { + TreeNode root = new TreeNode(8); + root.left = new TreeNode(3); + root.right = new TreeNode(10); + root.left.left = new TreeNode(1); + root.left.right = new TreeNode(6); + root.right.right = new TreeNode(14); + root.right.right.left = new TreeNode(13); + root.left.right.left = new TreeNode(4); + root.left.right.right = new TreeNode(7); + List> ans = travel(root); + for(List l:ans){ + System.out.println(l); + } + } + static List> travel(TreeNode root){ + List> list = new ArrayList<>(); + if(root==null) return list; + LinkedList q = new LinkedList<>(); + q.addLast(root); + while(!q.isEmpty()){ + int size = q.size(); + List l = new ArrayList<>(); + while(size>0){ + TreeNode node = q.poll(); + while(node!=null){ + l.add(node.val); + if(node.right!=null){ + q.addLast(node.right); + } + node = node.left; + } + size-=1; + } + + list.add(l); + } + return list; + } +} diff --git a/Trees/DiameterII.java b/Trees/DiameterII.java new file mode 100644 index 0000000..3be874e --- /dev/null +++ b/Trees/DiameterII.java @@ -0,0 +1,16 @@ +package Trees; + +import Trees.BinaryTree.*; +public class DiameterII { + static int diameter(TreeNode root){ + return help(root)[0]; + } + static int[] help(TreeNode root){ + if(root==null) return new int[]{0,-1}; + int[] left = help(root.left); + int[] right = help(root.right); + int dia = Math.max(left[0], Math.max(right[0], left[1]+right[1]+2)); + int height = Math.max(left[1], right[1])+1; + return new int[]{dia,height}; + } +} diff --git a/Trees/DiameterOfNaryTree.java b/Trees/DiameterOfNaryTree.java new file mode 100644 index 0000000..9181035 --- /dev/null +++ b/Trees/DiameterOfNaryTree.java @@ -0,0 +1,41 @@ +package Trees; + +import java.util.ArrayList; + +public class DiameterOfNaryTree { + static class Node{ + int data; + ArrayList child; + Node(int data){ + this.data= data; + child = new ArrayList<>(); + } + } + public static void main(String[] args) { + + } + static int dia = 0; + static int l = 0; + static int sl = 0; + public int dia(Node root){ + if(root==null) return 0; + int max = 0; + for(Node child:root.child){ + int h = dia(child); + max = Math.max(max, h); + if(h>=l){ + sl = l; + l = h; + } + else if(h>sl){ + sl = h; + } + } + if(dia>l+sl+2){ + dia = l+sl+2; + } + return max+1; + } + + +} diff --git a/Trees/DiameterOfTree.java b/Trees/DiameterOfTree.java new file mode 100644 index 0000000..de9c738 --- /dev/null +++ b/Trees/DiameterOfTree.java @@ -0,0 +1,22 @@ +package Trees; + +import Trees.BinaryTree.*; +public class DiameterOfTree { + public static void main(String[] args) { + + } + static int max = 0; + public int diameter(TreeNode root){ + help(root); + return max; + } + private int help(TreeNode node){ + if(node==null) return -1; + int left = help(node.left); + int right = help(node.right); + max = Math.max(max, left+right+2); + return Math.max(left, right)+1; + + } + +} diff --git a/Trees/DistributeCoins.java b/Trees/DistributeCoins.java new file mode 100644 index 0000000..487e81f --- /dev/null +++ b/Trees/DistributeCoins.java @@ -0,0 +1,29 @@ +package Trees; + +import Trees.BinaryTree.*; +public class DistributeCoins { + public static void main(String[] args) { + + } + static int count = 0; + static int dist(TreeNode root){ + if(root==null) return 0; + help(root, null); + return count; + } + static void help(TreeNode root, TreeNode parent){ + if(root==null) return; + help(root.left, root); + help(root.right, root); + if(root.val<1 && parent!=null){ + int dif = 1-root.val; + count+=dif; + parent.val-=dif; + } + else if(root.val>1 && parent!=null){ + int dif = root.val-1; + count+=dif; + parent.val+=dif; + } + } +} diff --git a/Trees/FlattenABST.java b/Trees/FlattenABST.java new file mode 100644 index 0000000..514feca --- /dev/null +++ b/Trees/FlattenABST.java @@ -0,0 +1,26 @@ +package Trees; +import Trees.BinaryTree.*; +public class FlattenABST { + public static void main(String[] args) { + + } + public void flatten(TreeNode root) { + flattenHelp(root); + } + public TreeNode flattenHelp(TreeNode root){ + if(root==null) return null; + TreeNode left = flattenHelp(root.left); + TreeNode right = flattenHelp(root.right); + root.left = null; + root.right = left; + TreeNode temp = root; + if(temp!=null){ + while(temp.right!=null){ + temp = temp.right; + } + temp.right = right; + } + return root; + } + +} diff --git a/Trees/HasPathSum.java b/Trees/HasPathSum.java new file mode 100644 index 0000000..10d7326 --- /dev/null +++ b/Trees/HasPathSum.java @@ -0,0 +1,14 @@ +package Trees; + +import Trees.BinaryTree.*; +public class HasPathSum { + public static void main(String[] args) { + + } + static boolean find(TreeNode root,int targetSum){ + if(root==null) return false; + targetSum-=root.val; + if(root.left==null && root.right==null && targetSum==0) return true; + return find(root.left, targetSum)||find(root.right, targetSum); + } +} diff --git a/Trees/HouseRobber.java b/Trees/HouseRobber.java new file mode 100644 index 0000000..aef7a8f --- /dev/null +++ b/Trees/HouseRobber.java @@ -0,0 +1,30 @@ +package Trees; + +import Trees.BinaryTree.*; +public class HouseRobber { + public static void main(String[] args) { + + } + static int rob(TreeNode root){ + if(root==null) return 0; + Pair ans = help(root); + return Math.max(ans.yes, ans.no); + } + static class Pair{ + int yes; + int no; + Pair(){ + yes = 0; + no = 0; + } + } + static Pair help(TreeNode root){ + if(root==null) return new Pair(); + Pair l = help(root.left); + Pair r = help(root.right); + Pair ans = new Pair(); + ans.yes = root.val + l.no + r.no; + ans.no = Math.max(l.no, l.yes)+Math.max(r.no, r.yes); + return ans; + } +} diff --git a/Trees/ImageMultiplication.java b/Trees/ImageMultiplication.java new file mode 100644 index 0000000..c7f8c55 --- /dev/null +++ b/Trees/ImageMultiplication.java @@ -0,0 +1,26 @@ +package Trees; + +import Trees.BinaryTree.*; +public class ImageMultiplication { + public static void main(String[] args) { + + } + static int sum = 0; + static int multiply(TreeNode root){ + if(root==null){ + return 0; + } + if(root.left!=null && root.right!=null){ + find(root.left, root.right); + } + return sum+(root.val*root.val); + } + static void find(TreeNode n1, TreeNode n2){ + if(n1==null||n2==null) return; + if(n1!=null && n2!=null){ + sum+= n1.val*n2.val; + } + find(n1.left, n2.right); + find(n1.right, n2.left); + } +} diff --git a/Trees/KDistanceAway.java b/Trees/KDistanceAway.java new file mode 100644 index 0000000..e10ab9a --- /dev/null +++ b/Trees/KDistanceAway.java @@ -0,0 +1,55 @@ +package Trees; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +import Trees.BinaryTree.*; +public class KDistanceAway { + public static void main(String[] args) { + + } + static List distanceK(TreeNode root, TreeNode target, int k){ + List res = new ArrayList<>(); + if(root==null) return res; + HashMap parentMap = new HashMap<>(); + findParent(parentMap,root); + Queue queue = new LinkedList<>(); + HashSet set = new HashSet<>(); + queue.add(target); + while(!queue.isEmpty()){ + int size = queue.size(); + for(int i=0;i map,TreeNode root){ + if(root==null) return; + if(root.left!=null) map.put(root.left, root); + if(root.right!=null) map.put(root.right, root); + findParent(map, root.left); + findParent(map, root.right); + + } +} diff --git a/Trees/KthSmallestInteger.java b/Trees/KthSmallestInteger.java new file mode 100644 index 0000000..abb04c9 --- /dev/null +++ b/Trees/KthSmallestInteger.java @@ -0,0 +1,23 @@ +package Trees; + +import Trees.BST.*; +public class KthSmallestInteger { + + public static void main(String[] args) { + + } + // another solution , iterative inorder + static BSTNode kth(BSTNode root, int k){ + if(root==null) return null; + if(k==root.lcount+1){ + return root; + } + if(kp2 + static TreeNode LCA(TreeNode root, int p1, int p2){ + if(root==null) return null; + if(root.val>p1 && root.val>p2) return LCA(root.left, p1, p2); + else if(root.val map; + Entry start,end; + int LRU_SIZE; + public LeastRecentlyUsedCache(){ + map = new HashMap<>(); + LRU_SIZE = 4; + } + public int getEntry(int key){ + if(map.containsKey(key)){ + Entry entry = map.get(key); + removeNode(entry); + addAtTop(entry); + return entry.value; + } + return -1; + } + public void putEntry(int key, int value){ + if(map.containsKey(key)){ + Entry entry = map.get(key); + entry.value = value; + removeNode(entry); + addAtTop(entry); + }else{ + Entry node = new Entry(); + node.left = null; + node.right = null; + node.key = key; + node.value = value; + if(map.size()>LRU_SIZE){ + map.remove(end.key); + removeNode(end); + } + addAtTop(node); + map.put(key, node); + } + } + private void addAtTop(Entry node){ + node.right = start; + node.left = null; + if(start!=null){ + start.left = node; + } + start= node; + if(end==null){ + end = start; + } + } + private void removeNode(Entry node){ + if(node.left!=null){ + node.left.right = node.right; + }else{ + start = node.right; + } + if(node.right!=null){ + node.right.left = node.left; + }else{ + end = node.left; + } + } + +} diff --git a/Trees/LeftView.java b/Trees/LeftView.java new file mode 100644 index 0000000..0f46a19 --- /dev/null +++ b/Trees/LeftView.java @@ -0,0 +1,39 @@ +package Trees; + +import java.util.LinkedList; +import java.util.Queue; + +import Trees.BinaryTree.*; +public class LeftView { + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.root = new TreeNode(12); + tree.root.left = new TreeNode(10); + tree.root.right = new TreeNode(30); + tree.root.right.left = new TreeNode(25); + tree.root.right.right = new TreeNode(40); + printLeft(tree.root); + // BinaryTree.display(tree.root); + } + static void printLeft(TreeNode root){ + if(root==null) return; + Queue queue = new LinkedList(); + queue.add(root); + queue.add(null); + System.out.print(root.val+" "); + while(!queue.isEmpty()){ + TreeNode node = queue.remove(); + if(node==null && !queue.isEmpty()){ + queue.add(null); + System.out.print(queue.peek().val+" "); + } + if(node!=null && node.left!=null){ + queue.add(node.left); + } + if(node!=null && node.right!=null){ + queue.add(node.right); + } + + } + } +} diff --git a/Trees/LongestZigZagPath.java b/Trees/LongestZigZagPath.java new file mode 100644 index 0000000..dcf6f53 --- /dev/null +++ b/Trees/LongestZigZagPath.java @@ -0,0 +1,34 @@ +package Trees; + +import Trees.BinaryTree.*; +public class LongestZigZagPath { + public static void main(String[] args) { + + } + static class Pair{ + int left; + int right; + int max; + Pair(){ + //to be set wrt edge + left = -1; + right = -1; + } + } + static int longest(TreeNode root){ + if(root==null) return 0; + Pair pair = help(root); + return pair.max; + } + static Pair help(TreeNode root){ + if(root==null) return null; + Pair left = help(root.left); + Pair right = help(root.right); + Pair pair = new Pair(); + pair.max = Math.max(Math.max(left.max, right.max), Math.max(left.right, right.left)+1); + pair.left = left.right+1; + pair.right = right.left+1; + return pair; + + } +} diff --git a/Trees/LongestZigZagPathII.java b/Trees/LongestZigZagPathII.java new file mode 100644 index 0000000..2851234 --- /dev/null +++ b/Trees/LongestZigZagPathII.java @@ -0,0 +1,23 @@ +package Trees; + +import Trees.BinaryTree.*; +public class LongestZigZagPathII { + public static void main(String[] args) { + + } + //faster + static int max = -1; + public int longestZigZag(TreeNode root) { + if(root==null||(root.left==null && root.right==null)) return 0; + help(root); + return max; + } + public int[] help(TreeNode root){ + if(root==null) return new int[]{-1,-1}; + int[] left = help(root.left); + int[] right = help(root.right); + max = Math.max(max,Math.max(left[1],right[0])+1); + return new int[]{left[1]+1,right[0]+1}; + } +} + diff --git a/Trees/MaxDiffBwNodeAndAncestors.java b/Trees/MaxDiffBwNodeAndAncestors.java new file mode 100644 index 0000000..75902df --- /dev/null +++ b/Trees/MaxDiffBwNodeAndAncestors.java @@ -0,0 +1,18 @@ +package Trees; + +import Trees.BinaryTree.*; +public class MaxDiffBwNodeAndAncestors { + public static void main(String[] args) { + + } + static int find(TreeNode root, int res){ + if(root==null) return 0; + if(root.left==null && root.right==null) return root.val; + int l = find(root.left, res); + int r = find(root.right, res); + int val = Math.min(l, r); + res = Math.max(res, root.val-val); + return Math.min(val, root.val); + } + +} diff --git a/Trees/MaxPathBwAnyNodes.java b/Trees/MaxPathBwAnyNodes.java new file mode 100644 index 0000000..074198b --- /dev/null +++ b/Trees/MaxPathBwAnyNodes.java @@ -0,0 +1,24 @@ +package Trees; + +import Trees.BinaryTree.*; +public class MaxPathBwAnyNodes { + static int result = Integer.MIN_VALUE; + // 3 cases-> Node part of the path + // Node is the root of the path + // Node is not a part of the path + public int maxPathSum(TreeNode root) { + if(root==null) return 0; + help(root); + return result; + } + private int help(TreeNode root){ + if(root==null) return 0; + int l = help(root.left); + int r = help(root.right); + int ms = Math.max(Math.max(l,r)+root.val,root.val);// node is part of the tree + int ms1 = Math.max(ms,l+r+root.val);// node is root of max sum tree + result = Math.max(result,ms1); + return l+r+root.val; + } + +} diff --git a/Trees/MaxPathSum.java b/Trees/MaxPathSum.java new file mode 100644 index 0000000..54a3a9c --- /dev/null +++ b/Trees/MaxPathSum.java @@ -0,0 +1,20 @@ +package Trees; + +import Trees.BinaryTree.*; +public class MaxPathSum { + public static void main(String[] args) { + } + static int max = Integer.MIN_VALUE; + public int getMax(TreeNode node){ + if(node==null) return Integer.MIN_VALUE; + if(node.left==null && node.right==null) return node.val; + int l = getMax(node.left); + int r = getMax(node.right); + if(node.left!=null && node.right!=null){ + if(l+r+node.val>max) max = l+r+node.val; + } + return Math.max(l, r)+node.val; + + } +} + diff --git a/Trees/MaxProductSplittedBinaryTree.java b/Trees/MaxProductSplittedBinaryTree.java new file mode 100644 index 0000000..cded9e9 --- /dev/null +++ b/Trees/MaxProductSplittedBinaryTree.java @@ -0,0 +1,31 @@ +package Trees; + +import Trees.BinaryTree.*; +public class MaxProductSplittedBinaryTree { + static int m = 1000000007; + long max; + public int maxProduct(TreeNode root) { + max = Integer.MIN_VALUE; + long sum = sum(root); + traverseAndFind(root,sum); + max = max%m; + // System.out.println(sum); + return (int) max; + + } + public int traverseAndFind(TreeNode root,long sum){ + if(root==null) return 0; + //including in left subtree + int l = traverseAndFind(root.left,sum)%m; + int r = traverseAndFind(root.right,sum)%m; + // System.out.println(s2); + max = Math.max(max,l*(sum-l)); + max = Math.max(max,r*(sum-r)); + return (l+r+root.val)%m; + + } + public long sum(TreeNode root){ + if(root==null) return 0; + return root.val+sum(root.left)+sum(root.right); + } +} diff --git a/Trees/Merge2BST.java b/Trees/Merge2BST.java new file mode 100644 index 0000000..f7a9f77 --- /dev/null +++ b/Trees/Merge2BST.java @@ -0,0 +1,77 @@ +package Trees; +import java.util.ArrayList; + +import Trees.BinaryTree.*; +public class Merge2BST { + public static void main(String[] args) { + BinaryTree tree1 = new BinaryTree(); + BinaryTree tree2 = new BinaryTree(); + tree1.root =new TreeNode(2); + tree1.root.left =new TreeNode(1); + tree1.root.right =new TreeNode(3); + tree2.root = new TreeNode(5); + tree2.root.right = new TreeNode(6); + tree2.root.left = new TreeNode(4); + tree1.root = merge(tree1.root, tree2.root); + display(tree1.root); + } + static void display(TreeNode root){ + if(root==null) return; + String str = root.val+" L: "; + str+=root.left==null?"null R: ":root.left.val+" R: "; + str+=root.right==null?"null":root.right.val+""; + System.out.println(str); + display(root.left); + display(root.right); + + } + static TreeNode merge(TreeNode root1,TreeNode root2){ + if(root1==null) return root2; + if(root2==null) return root1; + ArrayList r1 = new ArrayList<>(); + ArrayList r2 = new ArrayList<>(); + fill(root1,r1); + fill(root2,r2); + ArrayList arr= merge2Arrays(r1,r2); + return make(arr,0,arr.size()-1); + } + static TreeNode make(ArrayList arr, int i, int j){ + if(i>j) return null; + int mid = i+(j-i)/2; + TreeNode root = new TreeNode(arr.get(mid)); + root.left = make(arr, i, mid-1); + root.right = make(arr, mid+1, j); + return root; + } + static ArrayList merge2Arrays(ArrayList arr1, ArrayList arr2){ + if(arr1.size()==0) return arr2; + if(arr2.size()==0) return arr1; + ArrayList arr = new ArrayList<>(); + int i=0,j=0; + while(i arr){ + if(node==null) return; + fill(node.left, arr); + arr.add(node.val); + fill(node.right, arr); + } + +} diff --git a/Trees/Merge2BSTOptimal.java b/Trees/Merge2BSTOptimal.java new file mode 100644 index 0000000..e4df3f1 --- /dev/null +++ b/Trees/Merge2BSTOptimal.java @@ -0,0 +1,100 @@ +package Trees; + + +import Trees.BinaryTree.*; +public class Merge2BSTOptimal { + public static void main(String[] args) { + BinaryTree tree1 = new BinaryTree(); + BinaryTree tree2 = new BinaryTree(); + tree1.root =new TreeNode(2); + tree1.root.left =new TreeNode(1); + tree1.root.right =new TreeNode(3); + tree2.root = new TreeNode(5); + tree2.root.right = new TreeNode(6); + tree2.root.left = new TreeNode(4); + tree1.root = merge(tree1.root, tree2.root); + } + static void display(TreeNode root){ + if(root==null) return; + String str = root.val+" L: "; + str+=root.left==null?"null R: ":root.left.val+" R: "; + str+=root.right==null?"null":root.right.val+""; + System.out.println(str); + display(root.left); + display(root.right); + + } + static TreeNode merge(TreeNode root1,TreeNode root2){ + if(root1==null) return root2; + if(root2==null) return root1; + TreeNode head1 = BSTtoDLL(root1); + TreeNode head2 = BSTtoDLL(root2); + TreeNode node = mergeTwoSortedLL(head1, head2); + return convert(node); + } + static TreeNode convert(TreeNode root){ + if(root==null||(root.left==null && root.right==null)) return root; + TreeNode mid = mid(root); + TreeNode temp = mid.right; + if(mid.left!=null){ + mid.left.right = null; + } + mid.left = null; + if(mid.right!=null){ + mid.right.left = null; + } + mid.right = null; + mid.left = convert(root); + mid.right = convert(temp); + return mid; + } + static TreeNode mid(TreeNode node){ + TreeNode slow = node; + TreeNode fast = node; + while(fast.right!=null && fast.right.right!=null){ + fast = fast.right.right; + slow = slow.right; + } + return slow; + + } + static TreeNode mergeTwoSortedLL(TreeNode node1, TreeNode node2){ + if(node1==null) return node2; + if(node2==null) return node1; + if(node1.val a1 = fill(root,a); + ArrayList a2 = fill(root,b); + Collections.reverse(a1); + Collections.reverse(a2); + int j=0; + while(j fill(TreeNode root, int data){ + if(root==null) return new ArrayList<>(); + if(root.val==data){ + ArrayList arr = new ArrayList<>(); + arr.add(root.val); + return arr; + } + ArrayList l = fill(root.left,data); + ArrayList r = fill(root.right,data); + if(!l.isEmpty()){ + l.add(root.val); + return l; + } + if(!r.isEmpty()){ + r.add(root.val); + return r; + } + return new ArrayList<>(); + } +} diff --git a/Trees/PathSumII.java b/Trees/PathSumII.java new file mode 100644 index 0000000..59505e1 --- /dev/null +++ b/Trees/PathSumII.java @@ -0,0 +1,34 @@ +package Trees; + +import java.util.ArrayList; +import java.util.List; + +import Trees.BinaryTree.*; +public class PathSumII { + public static void main(String[] args) { + + } + static List> list; + public List> pathSum(TreeNode root, int targetSum) { + list = new ArrayList<>(); + if(root==null) return list; + help(root,targetSum,new ArrayList<>() ); + return list; + } + private void help(TreeNode root, int targetSum,ArrayList ans){ + //backtracking + if(root==null) return; + ans.add(root.val); + if(root.left==null && root.right==null && targetSum==root.val){ + list.add(new ArrayList<>(ans)); + ans.remove(ans.size()-1); + return; + } + targetSum-=root.val; + help(root.left,targetSum,ans); + help(root.right,targetSum,ans); + + + ans.remove(ans.size()-1); + } +} diff --git a/Trees/PathSumIII.java b/Trees/PathSumIII.java new file mode 100644 index 0000000..a5c9426 --- /dev/null +++ b/Trees/PathSumIII.java @@ -0,0 +1,21 @@ +package Trees; + +import Trees.BinaryTree.*; +// O(n^2) +public class PathSumIII { + int count = 0; + public int pathSum(TreeNode root, int sum){ + findPathSum(root, sum, 0); + pathSum(root.left, sum); + pathSum(root.right, sum); + return count; + } + void findPathSum(TreeNode root, int sum, int currSum){ + if(root==null) return; + currSum+= root.val; + if(sum==currSum) count++; + findPathSum(root.left, sum, currSum); + findPathSum(root.right, sum, currSum); + } + +} diff --git a/Trees/PathSumIIOptimum.java b/Trees/PathSumIIOptimum.java new file mode 100644 index 0000000..40a66db --- /dev/null +++ b/Trees/PathSumIIOptimum.java @@ -0,0 +1,31 @@ +package Trees; + +import java.util.HashMap; + +import Trees.BinaryTree.*; +public class PathSumIIOptimum { + // O(n) approach + // Associate with target sum in array + int count = 0; + public int pathSum(TreeNode root, int sum){ + if(root==null) return 0; + HashMap map = new HashMap<>(); + map.put(0, 1); + findPathSum(root,0,sum,map); + return count; + } + private void findPathSum(TreeNode root, int currSum, int sum, HashMap map){ + if(root==null) return; + currSum+= root.val; + if(map.containsKey(currSum-sum)){ + count+= map.get(currSum-sum); + } + map.put(currSum, map.getOrDefault(currSum, 1)+1);//increase the frequency OR add + findPathSum(root.left, currSum, sum, map); + findPathSum(root.right, currSum, sum, map); + map.put(currSum, map.get(currSum)-1);//remove it back on the go + return; + } + + +} diff --git a/Trees/PopulatingNextRightPointers.java b/Trees/PopulatingNextRightPointers.java new file mode 100644 index 0000000..6da8476 --- /dev/null +++ b/Trees/PopulatingNextRightPointers.java @@ -0,0 +1,29 @@ +package Trees; + +public class PopulatingNextRightPointers { + static class Node{ + int val; + Node left,right, next; + } + public Node connect(Node root) { + if(root==null) return null; + root.next = null; + help(root.left,root); + help(root.right,root); + return root; + } + public void help(Node node, Node parent){ + if(node==null) return; + if(parent.right==node && parent.next==null){ + node.next = null; + } + else if(parent.right==node && parent.next!=null){ + node.next = parent.next.left; + } + else{ + node.next= parent.right; + } + help(node.left, node); + help(node.right, node); + } +} diff --git a/Trees/RecoverBST.java b/Trees/RecoverBST.java new file mode 100644 index 0000000..46f6a41 --- /dev/null +++ b/Trees/RecoverBST.java @@ -0,0 +1,43 @@ +package Trees; + +import java.util.ArrayList; +import java.util.Collections; + +import Trees.BinaryTree.*; +public class RecoverBST { + public static void main(String[] args) { + + } + public void recoverTree(TreeNode root) { + ArrayList arr = new ArrayList<>(); + in(root,arr); + Collections.sort(arr); + root = build(arr,0,arr.size()-1); + System.out.println(root.val); + } + public void in(TreeNode root ,ArrayList arr){ + if(root==null) return; + in(root.left,arr); + arr.add(root.val); + in(root.right,arr); + } + public void sort(ArrayList arr){ + for(int i=1;i0 && arr.get(j)>key){ + arr.set((j+1) ,arr.get(j)); + j--; + } + arr.set(j,key); + } + } + public TreeNode build(ArrayList arr, int i, int j){ + if(i>j) return null; + int mid = i+(j-i)/2; + TreeNode root = new TreeNode(arr.get(mid)); + root.left = build(arr,i,mid-1); + root.right = build(arr,mid+1,j); + return root; + } +} diff --git a/Trees/RecoverBSTII.java b/Trees/RecoverBSTII.java new file mode 100644 index 0000000..b40c66a --- /dev/null +++ b/Trees/RecoverBSTII.java @@ -0,0 +1,26 @@ +package Trees; + +import Trees.BinaryTree.*; +public class RecoverBSTII { + TreeNode prev = null, first = null, second = null; + public void recoverTree(TreeNode root){ + find(root); + int temp = first.val; + first.val = second.val; + second.val = temp; + } + private void find(TreeNode curr){ + if(curr==null) return; + find(curr.left); + if(prev!=null && prev.val>curr.val){ + if(first==null){ + first = prev; + } + second = curr; + } + prev = curr; + find(curr.right); + } + + +} diff --git a/Trees/ReverseLevelOrder.java b/Trees/ReverseLevelOrder.java new file mode 100644 index 0000000..5a2ff64 --- /dev/null +++ b/Trees/ReverseLevelOrder.java @@ -0,0 +1,39 @@ +package Trees; + +import java.util.Queue; +import java.util.Stack; +import java.util.LinkedList; + +import Trees.BinaryTree.*; +public class ReverseLevelOrder { + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.root = new TreeNode(1); + tree.root.left = new TreeNode(2); + tree.root.right = new TreeNode(3); + tree.root.right.left = new TreeNode(4); + tree.root.left.right = new TreeNode(5); + tree.root.left.left = new TreeNode(6); + printReverse(tree.root); + + } + static void printReverse(TreeNode node){ + if(node==null) return; + Stack st = new Stack<>(); + Queue queue = new LinkedList<>(); + queue.add(node); + while(!queue.isEmpty()){ + TreeNode n = queue.remove(); + st.push(n); + if(n.left!=null){ + queue.add(n.left); + } + if(n.right!=null){ + queue.add(n.right); + } + } + while(!st.isEmpty()){ + System.out.print(st.pop().val+" "); + } + } +} diff --git a/Trees/RightView.java b/Trees/RightView.java new file mode 100644 index 0000000..380a67a --- /dev/null +++ b/Trees/RightView.java @@ -0,0 +1,41 @@ +package Trees; +import java.util.LinkedList; +import java.util.Queue; + +import Trees.BinaryTree.*; +public class RightView { + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.root = new TreeNode(12); + tree.root.left = new TreeNode(10); + tree.root.right = new TreeNode(30); + tree.root.right.left = new TreeNode(25); + tree.root.right.right = new TreeNode(40); + printRight(tree.root); + } + static void printRight(TreeNode root){ + if(root==null) return; + Queue queue = new LinkedList(); + queue.add(root); + queue.add(null); + while(!queue.isEmpty()){ + TreeNode node = queue.remove(); + if(node==null && !queue.isEmpty()){ + queue.add(null); + } + if(node!=null && node.left!=null){ + queue.add(node.left); + } + if(node!=null && node.right!=null){ + queue.add(node.right); + } + if(node!=null && queue.peek()==null){ + System.out.print(node.val+" "); + } + + } + + } +} + + diff --git a/Trees/SerializeAndDeserialize.java b/Trees/SerializeAndDeserialize.java new file mode 100644 index 0000000..ef33628 --- /dev/null +++ b/Trees/SerializeAndDeserialize.java @@ -0,0 +1,45 @@ +package Trees; + +import Trees.BinaryTree.TreeNode; + +public class SerializeAndDeserialize { + static String ans =""; + public String serialize(TreeNode root) { + help(root); + System.out.println(ans); + return ans; + } + private void help(TreeNode root){ + if(root==null){ + ans+="*"; + return; + } + ans+=root.val+""; + help(root.left); + help(root.right); + + } + + // Decodes your encoded data to tree. + public TreeNode deserialize(String data) { +// 4-7**-3-9960*-1**6-4****-7-65***-69-2****-3-4*** + if(i>=data.length()) return null; + if(data.charAt(i)=='*'){ + i+=1; + return null; + } + TreeNode root; + if(data.charAt(i)=='-'){ + root = new TreeNode((data.charAt(i+1)-'0')*-1); + i+=2; + }else{ + root = new TreeNode(data.charAt(i)-'0'); + i+=1; + } + + root.left = deserialize(data); + root.right = deserialize(data); + return root; + } + static int i =0; +} diff --git a/Trees/SumOfDistancesInTree.java b/Trees/SumOfDistancesInTree.java new file mode 100644 index 0000000..4ae6e4e --- /dev/null +++ b/Trees/SumOfDistancesInTree.java @@ -0,0 +1,7 @@ +package Trees; +// https://leetcode.com/problems/sum-of-distances-in-tree/discuss/414347/Simple-O(N)-DP-on-Trees-Solution +public class SumOfDistancesInTree { + public static void main(String[] args) { + + } +} diff --git a/Trees/SumRootToLeaf.java b/Trees/SumRootToLeaf.java new file mode 100644 index 0000000..937533b --- /dev/null +++ b/Trees/SumRootToLeaf.java @@ -0,0 +1,30 @@ +package Trees; + +import Trees.BinaryTree.*; +public class SumRootToLeaf { + public static void main(String[] args) { + + } + int sum = 0; + public int sumNumbers(TreeNode root) { + if(root==null) return 0; + help(root,0); + return sum; + } + public void help(TreeNode root,int num){ + if(root==null) return; + num = num*10+root.val; + if(root.left==null && root.right==null){ + sum+=num; + return; + } + if(root.left!=null){ + help(root.left,num); + } + if(root.right!=null){ + help(root.right,num); + } + + } +} + diff --git a/Trees/TopView.java b/Trees/TopView.java new file mode 100644 index 0000000..96e3b67 --- /dev/null +++ b/Trees/TopView.java @@ -0,0 +1,45 @@ +package Trees; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import Trees.BinaryTree.*; + +public class TopView { + public static void main(String[] args) { + BinaryTree tree = new BinaryTree(); + tree.root = new TreeNode(1); + tree.root.left = new TreeNode(2); + tree.root.right = new TreeNode(3); + tree.root.left.left = new TreeNode(4); + tree.root.left.right = new TreeNode(5); + tree.root.right.right = new TreeNode(7); + tree.root.right.left = new TreeNode(6); + System.out.println(top(tree.root)); + } + static List top(TreeNode root){ + List ans = new ArrayList<>(); + if(root==null) return ans; + Map map = new HashMap<>(); + Queue queue = new LinkedList<>(); + queue.add(new Point(0, 0, root)); + int minIndex = Integer.MAX_VALUE; + int maxIndex = Integer.MIN_VALUE; + while(!queue.isEmpty()){ + Point p = queue.poll(); + map.putIfAbsent(p.x, p.root.val); + minIndex = Math.min(minIndex,p.x); + maxIndex = Math.max(maxIndex,p.x); + if(p.root.left!=null) queue.add(new Point(p.x-1, p.y+1, p.root.left)); + if(p.root.right!=null) queue.add(new Point(p.x+1, p.y+1, p.root.right)); + } + for(int i=minIndex;i<=maxIndex;i++){ + ans.add(map.get(i)); + } + return ans; + + + } +} diff --git a/Trees/TweetCountPerFreq.java b/Trees/TweetCountPerFreq.java new file mode 100644 index 0000000..ea3aaf3 --- /dev/null +++ b/Trees/TweetCountPerFreq.java @@ -0,0 +1,36 @@ +package Trees; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; +public class TweetCountPerFreq { + private Map> record; + public TweetCountPerFreq(){ + record = new HashMap<>(); + } + public void recordTweet(String tweetName, int time){ + record.putIfAbsent(tweetName, new TreeMap()); + TreeMap tm = record.get(tweetName); + tm.put(time, tm.getOrDefault(time, 0)+1); + } + public List getTweetCountsPerFrequency(String freq, String tweetName, int startTime, int endTime){ + int split = 60; + if(freq.equals("hour")) split = 60*60; + if(freq.equals("day")) split = 60*60*24; + List res = new ArrayList<>(); + TreeMap tm = record.get(tweetName); + if(!record.containsKey(tweetName)) return res; + for(int start = startTime;start<=endTime;start+=split){ + int count = 0; + int end = Math.min(endTime+1,start+split); + Map sub = tm.subMap(start,end); + for(int val:sub.values()){ + count+=val; + } + res.add(count); + } + return res; + } +} diff --git a/Trees/ValidateBST.java b/Trees/ValidateBST.java new file mode 100644 index 0000000..f55ef9d --- /dev/null +++ b/Trees/ValidateBST.java @@ -0,0 +1,35 @@ +package Trees; + +import Trees.BinaryTree.*; +public class ValidateBST { + public static void main(String[] args) { + + } + public boolean isValidBST(TreeNode root) { + if(root==null) return true; + BST ans = help(root); + return ans.isBST; + } + class BST{ + long leftMax; + long rightMin; + boolean isBST; + BST(){ + leftMax = Long.MIN_VALUE; + rightMin = Long.MAX_VALUE; + isBST = true; + } + } + public BST help(TreeNode root){ + if(root==null){ + return new BST(); + } + BST l = help(root.left); + BST r = help(root.right); + BST ans = new BST(); + ans.leftMax = Math.max(root.val,Math.max(l.leftMax, r.leftMax)); + ans.rightMin = Math.min(root.val,Math.min(l.rightMin,r.rightMin)); + ans.isBST = root.vall.leftMax && l.isBST && r.isBST; + return ans; + } +} diff --git a/Trees/ValidateBSTII.java b/Trees/ValidateBSTII.java new file mode 100644 index 0000000..ad5a5e3 --- /dev/null +++ b/Trees/ValidateBSTII.java @@ -0,0 +1,21 @@ +package Trees; + +import Trees.BinaryTree.*; +public class ValidateBSTII { + public static void main(String[] args) { + + } + // 75/80 testcase passed + public boolean isValidBST(TreeNode root) { + if(root==null) return true; + return help(root,Long.MIN_VALUE,Long.MAX_VALUE); + } + public boolean help(TreeNode root, long min, long max){ + if(root==null) return true; + if(root.val< min || root.val>max) return false; + boolean l = help(root.left,min,root.val-1); + boolean r = help(root.right, root.val+1,max); + if(!l||!r) return false; + return true; + } +} diff --git a/Trees/VerticalOrder.java b/Trees/VerticalOrder.java new file mode 100644 index 0000000..0c376f8 --- /dev/null +++ b/Trees/VerticalOrder.java @@ -0,0 +1,63 @@ +package Trees; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.PriorityQueue; +import Trees.BinaryTree.*; + +class Point{ + int x; + int y; + TreeNode root; + Point(int x,int y, TreeNode root){ + this.x = x; + this.y = y; + this.root = root; + } +} + +public class VerticalOrder { + public static void main(String[] args) { + + } + public List> vertical(TreeNode root){ + List>res = new ArrayList<>(); + if(root==null) return res; + Map> map = new HashMap<>(); + Queue queue = new LinkedList<>(); + queue.offer(new Point(0, 0, root)); + Comparator comparator = (a,b) ->{ + if(a.y==b.y){ + return a.root.val-b.root.val; + }else{ + return a.y-b.y; + } + }; + int maxIdx = Integer.MIN_VALUE; + int minIdx = Integer.MAX_VALUE; + while(!queue.isEmpty()){ + Point point = queue.poll(); + root = point.root; + map.putIfAbsent(point.x, new PriorityQueue<>(comparator)); + map.get(point.x).add(point); + minIdx = Math.min(minIdx, point.x); + maxIdx = Math.max(maxIdx, point.x); + if(root.left!=null) queue.offer(new Point(point.x-1,point.y+1,point.root.left)); + if(root.right!=null) queue.offer(new Point(point.x+1, point.y+1, point.root.right)); + } + for(int i=minIdx;i<=maxIdx;i++){ + PriorityQueue pq = map.get(i); + List list = new ArrayList<>(); + while(!pq.isEmpty()){ + list.add(pq.poll().root.val); + } + res.add(list); + } + return res; + } +} diff --git a/Trees/VerticalOrderSum.java b/Trees/VerticalOrderSum.java new file mode 100644 index 0000000..9934b5a --- /dev/null +++ b/Trees/VerticalOrderSum.java @@ -0,0 +1,64 @@ +package Trees; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.LinkedList; +import java.util.Queue; +import java.util.TreeMap; + + +import Trees.BinaryTree.*; +public class VerticalOrderSum { + public static void main(String[] args) { + TreeNode root = new TreeNode(1); + root.left = (new TreeNode(2)); + root.right = (new TreeNode(3)); + root.left.left = (new TreeNode(4)); + root.left.right = (new TreeNode(5)); + root.right.left = (new TreeNode(6)); + root.right.right = (new TreeNode(7)); + sum(root); + } + static class Node { + int x; + TreeNode node; + Node(int x,TreeNode node){ + this.x = x; + this.node = node; + } + } + static class Help implements Comparator{ + @Override + public int compare(Node o1, Node o2) { + return o1.x-o2.x; + } + } + static void sum(TreeNode root){ + ArrayList ans = new ArrayList<>(); + if(root==null) return ; + Queue q = new LinkedList<>(); + TreeMap map = new TreeMap<>(); + q.add(new Node(0,root)); + while(!q.isEmpty()){ + Node n = q.poll(); + if(map.containsKey(n.x)){ + map.put(n.x, map.get(n.x)+n.node.val); + }else{ + map.put(n.x, n.node.val); + } + if(n.node.left!=null){ + q.add(new Node(n.x-1, n.node.left)); + } + if(n.node.right!=null){ + q.add(new Node(n.x+1,n.node.right)); + } + } + for(int key:map.keySet()){ + ans.add(key); + } + for(int i=0;i queue = new LinkedList<>(); + int max = 1; + queue.add(root); + queue.add(null); + int tMax = 0; + while(!queue.isEmpty()){ + TreeNode node = queue.poll(); + if(queue.isEmpty()){ + break; + } + if(node==null){ + max = Math.max(max, tMax); + queue.add(null); + tMax = 0; + } + if(node!=null && node.left!=null){ + queue.add(node.left); + tMax++; + } + if(node!=null && node.right!=null){ + queue.add(node.right); + tMax++; + } + } + return max; + + } +}