newProblems

Author: shashankch

src/trees/GenericTree.java

@@ -0,0 +1,77 @@
+package trees;
+
+public class GenericTree {
+
+    //depth=0;
+    public static void replaceWithDepthValue(GenericTreeNode<Integer> root,int depth){
+
+            if(root==null){
+                return;
+            }
+
+            root.data=depth;
+            for(GenericTreeNode<Integer>child:root.children){
+
+                replaceWithDepthValue(child,depth+1);
+
+            }
+        }
+
+    public static int countLeafNodes(GenericTreeNode<Integer> root){
+
+        if(root==null){
+            return 0;
+        }
+        if(root.children.size()==0){
+            return 1;
+        }
+
+        int count=0;
+        for(GenericTreeNode<Integer>child:root.children){
+            count+=countLeafNodes(child);
+        }
+
+        return count;
+
+    }
+
+
+    public static GenericTreeNode<Integer> findSecondLargest(GenericTreeNode<Integer> root){
+
+        if(root==null){
+
+            SecondMax res=new SecondMax();
+            res.first=null;
+            res.second=null;
+
+        }
+
+        SecondMax out=new SecondMax();
+        out.first=root;
+        out.second=null;
+
+        for(GenericTreeNode<Integer>child:root.children){
+
+
+
+        }
+
+    return null;
+
+    }
+
+
+
+}
+
+class SecondMax{
+
+    GenericTreeNode<Integer> first;
+    GenericTreeNode<Integer> second;
+
+    SecondMax(){
+
+    }
+
+
+        }

src/trees/GenericTreeNode.java

@@ -0,0 +1,15 @@
+package trees;
+
+import java.util.ArrayList;
+
+public class GenericTreeNode<T> {
+         T data;
+        ArrayList<GenericTreeNode<T> > children;
+
+        GenericTreeNode(T data){
+            this.data = data;
+            children = new ArrayList<GenericTreeNode<T>>();
+        }
+
+
+}

src/trees/InorderSuccessor.java

@@ -1,4 +1,80 @@
 package trees;
 
 public class InorderSuccessor {
+
+
+
+    public static BinaryTreeNode<Integer> getMin(BinaryTreeNode<Integer> node)
+    {
+        BinaryTreeNode<Integer> current = node;
+
+
+        while (current.left != null) {
+            current = current.left;
+        }
+        return current;
+    }
+
+
+    public static BinaryTreeNode<Integer> inorderSuccesor(BinaryTreeNode<Integer> root, BinaryTreeNode<Integer> node) {
+
+        if(node==null){
+            return null;
+        }
+        else if(node.right!=null){
+            return getMin(node.right);
+        }
+        else{
+            BinaryTreeNode<Integer> ancestor=root;
+            BinaryTreeNode<Integer> succ=null;
+            while(ancestor!=null){
+
+                if(node.data<ancestor.data){
+                    succ=ancestor;
+                    ancestor=ancestor.left;
+                }
+                else if(node.data>ancestor.data){
+
+                    ancestor=ancestor.right;
+
+                }
+                else{
+
+                    break;
+                }
+
+
+            }
+            return succ;
+        }
+
+
+    }
+
+    static BinaryTreeNode<Integer> next,res;
+public static void reverseInorder(BinaryTreeNode<Integer> root,BinaryTreeNode<Integer>node){
+
+        if(root==null) {
+            return;
+        }
+        reverseInorder(root.right,node);
+        if(root==node){
+            res=next;
+        }
+
+        next=root;
+        reverseInorder(root.left,node);
+
+}
+
+
+
+    public static BinaryTreeNode<Integer> inorderSuccesor2(BinaryTreeNode<Integer> root, BinaryTreeNode<Integer> node) {
+
+            res=null;
+            next=null;
+            reverseInorder(root,node);
+            return res;
+
+    }
 }

src/trees/KthSmallBST.java

@@ -28,5 +28,36 @@ public static int kthSmallestNode(BinaryTreeNode<Integer> root,int K){
 
     }
 
+//another way
+
+    public static int countallnodes(BinaryTreeNode<Integer> root){
+
+        if(root==null){
+            return 0;
+        }
+        return 1+countallnodes(root.left)+countallnodes(root.right);
+
+
+    }
+
+    public static int kthSmallestNode2(BinaryTreeNode<Integer> root,int K){
+
+        if(root==null){
+                return Integer.MIN_VALUE;
+        }
+        int leftsmallest=countallnodes(root.left);
+
+        if(leftsmallest>=K){
+                return kthSmallestNode2(root.left,K);
+        }
+
+        else if(leftsmallest==K-1){
+                return root.data;
+        }
+        else {
+                return kthSmallestNode(root.right, K-leftsmallest-1);
+        }
+    }
+
 
 }

src/trees/MedianBST.java

@@ -55,6 +55,11 @@ public static int count(BinaryTreeNode<Integer>root){
     }
 
     public static int median(BinaryTreeNode<Integer> root) {
+
+        if(root==null){
+            return 0;
+        }
+
         int nodes=count(root);
         boolean even=false;
         if(nodes%2==0){
@@ -98,7 +103,7 @@ public static int median(BinaryTreeNode<Integer> root) {
                 else{
 
                     pr.right=null;
-
+                   // prev=pr;
                     count++;
 
 
@@ -121,7 +126,7 @@ public static int median(BinaryTreeNode<Integer> root) {
 
         }
 
-        return 0;
+        return -1;
     }
 
 }