Add files via upload

Author: shatakshigarg

BST 1/BST TO LL.txt

@@ -0,0 +1,86 @@
+class PassNode<T>
+{
+	T head;
+    T tail;
+}
+public class Solution {
+
+	/*
+	 * Binary Tree Node class
+	 * 
+	 * class BinaryTreeNode<T> { T data; BinaryTreeNode<T> left; BinaryTreeNode<T>
+	 * right;
+	 * 
+	 * public BinaryTreeNode(T data) { this.data = data; } }
+	 */
+
+	/*
+	 * LinkedList Node Class
+	 *
+	 * 
+	 * class LinkedListNode<T> { T data; LinkedListNode<T> next;
+	 * 
+	 * public LinkedListNode(T data) { this.data = data; } }
+	 */
+
+	public static LinkedListNode<Integer> constructLinkedList(BinaryTreeNode<Integer> root) {
+        PassNode<LinkedListNode<Integer>> passNode= constructLinkedListHelper(root);
+        return passNode.head;
+	}
+    
+    public static PassNode<LinkedListNode<Integer>> constructLinkedListHelper(BinaryTreeNode<Integer> root)
+    {
+    	if(root==null)
+        {
+            return new PassNode<LinkedListNode<Integer>>();
+        }
+        
+        if (root.left==null && root.right==null)
+        {
+        	PassNode<LinkedListNode<Integer>> passNode = new PassNode<LinkedListNode<Integer>>();
+        	passNode.head=new LinkedListNode<Integer>(root.data);
+            passNode.tail=null;
+            return passNode;
+        }
+        
+        PassNode<LinkedListNode<Integer>> passNodeLeft = constructLinkedListHelper(root.left);
+        PassNode<LinkedListNode<Integer>> passNodeRight = constructLinkedListHelper(root.right);
+        PassNode<LinkedListNode<Integer>> passNode = new PassNode<LinkedListNode<Integer>>();
+        LinkedListNode<Integer> newNode=new LinkedListNode<Integer>(root.data);
+        
+        if (passNodeLeft.head==null)
+        {
+        	passNode.head=newNode;
+            //passNode.tail=newNode;
+        }
+        else
+        {
+        	passNode.head=passNodeLeft.head;
+        }
+        
+        if(passNodeLeft.tail==null)
+        {
+        	passNode.head.next=newNode;
+            passNode.tail=newNode;
+        }
+        else
+        {
+        	passNodeLeft.tail.next=newNode;
+            passNode.tail=newNode;
+        }
+        
+        if (passNodeRight.head!=null)
+        {
+        	passNode.tail.next=passNodeRight.head;
+            passNode.tail=passNodeRight.head;
+        }
+        
+        if(passNodeRight.tail!=null)
+        {
+        	passNode.tail=passNodeRight.tail;
+        }
+    
+        return passNode;
+   
+    }
+}

BST 1/CONSTRUCT BST.txt

@@ -0,0 +1,33 @@
+public class Solution {
+
+	/*	Binary Tree Node class 
+	 * 
+	 * 	class BinaryTreeNode<T> {
+			T data;
+			BinaryTreeNode<T> left;
+			BinaryTreeNode<T> right;
+			
+			public BinaryTreeNode(T data) {
+				this.data = data;
+			}
+		}
+		*/
+	
+		public static BinaryTreeNode<Integer> SortedArrayToBST(int[] arr, int n){
+            return SortedArrayToBSTHelper(arr,0,n-1);
+			
+		}
+    
+        public static BinaryTreeNode<Integer> SortedArrayToBSTHelper(int[] arr, int si, int ei){
+            if (si>ei)
+                return null;
+            
+            int mid=(si+ei)/2;
+            BinaryTreeNode<Integer> root = new BinaryTreeNode<Integer>(arr[mid]);
+            
+            root.left=SortedArrayToBSTHelper(arr,si,mid-1);
+            root.right=SortedArrayToBSTHelper(arr,mid+1,ei);
+            return root;
+			
+		}
+	}

BST 1/ELEMENTS BETWEEN K1 AND K2.txt

@@ -0,0 +1,52 @@
+import java.util.*;
+public class Solution {
+
+	/*	Binary Tree Node class 
+	 * 
+	 * 	class BinaryTreeNode<T> {
+			T data;
+			BinaryTreeNode<T> left;
+			BinaryTreeNode<T> right;
+			
+			public BinaryTreeNode(T data) {
+				this.data = data;
+			}
+		}
+		*/
+		
+    	private static ArrayList<Integer> arr = new ArrayList<Integer>();
+    
+        public static void elementsInRangeK1K2(BinaryTreeNode<Integer> root,int k1,int k2)
+        {
+            elementsInRangeK1K2Helper(root,k1,k2);
+            Collections.sort(arr);
+            for (int i:arr)
+                System.out.print(i+" ");
+        }
+		public static void elementsInRangeK1K2Helper(BinaryTreeNode<Integer> root,int k1,int k2){
+            
+            //Base case - if root=null
+            if (root==null)
+                return;
+            
+            int rootData=root.data;
+            if (rootData<k1)
+            {
+                elementsInRangeK1K2Helper(root.right,k1,k2);
+            }
+            else if (rootData>k2)
+            {
+                elementsInRangeK1K2Helper(root.left,k1,k2);
+            }
+            else
+            {
+                //System.out.print(rootData+" ");
+                arr.add(rootData);
+                elementsInRangeK1K2Helper(root.right,k1,k2);
+                elementsInRangeK1K2Helper(root.left,k1,k2);
+            }
+			
+		}
+		
+		
+	}

BST 1/LCA OF BST.txt

@@ -0,0 +1,29 @@
+public class Solution {
+
+	/*
+	 * Binary Tree Node class
+	 * 
+	 * class BinaryTreeNode<T> { T data; BinaryTreeNode<T> left; BinaryTreeNode<T> right;
+	 * 
+	 * public BinaryTreeNode(T data) { this.data = data; } }
+	 */
+
+
+	
+	public static int getLCA(BinaryTreeNode<Integer> root, int n1, int n2) {
+        if (root == null) 
+            return -1; 
+   
+        // If both n1 and n2 are smaller than root, then LCA lies in left 
+        if (root.data > n1 && root.data > n2) 
+            return getLCA(root.left, n1, n2); 
+   
+        // If both n1 and n2 are greater than root, then LCA lies in right 
+        if (root.data < n1 && root.data < n2)  
+            return getLCA(root.right, n1, n2); 
+   
+        return root.data; 
+        
+		
+	}
+}

BST 1/SEARCH IN BST.txt

@@ -0,0 +1,34 @@
+public class Solution {
+
+	/*
+	 * Binary Tree Node class
+	 * 
+	 * class BinaryTreeNode<T> { T data; BinaryTreeNode<T> left; BinaryTreeNode<T> right;
+	 * 
+	 * public BinaryTreeNode(T data) { this.data = data; } }
+	 */
+
+
+	public static boolean searchInBST(BinaryTreeNode<Integer> root, int k) {
+        if (root==null)
+        {
+            return false;
+        }
+
+        int rootData=root.data;
+        if (k<rootData)
+        {
+            return searchInBST(root.left,k);
+        }
+        else if(k>rootData)
+        {
+            return searchInBST(root.right,k);
+        }
+        else
+        {
+            return true;
+        }
+
+
+	}
+}