newProblems

Author: shashankch

src/linkedlist/AppendLastNToStart.java

@@ -0,0 +1,82 @@
+package linkedlist;
+
+public class AppendLastNToStart {
+
+    public static int length(LinkedListNode<Integer>head){
+
+        LinkedListNode<Integer>temp=head;
+        int count=0;
+        while(temp!=null){
+
+            count++;
+            temp=temp.next;
+        }
+
+        return count;
+
+    }
+    public static LinkedListNode<Integer> append(LinkedListNode<Integer> root, int n) {
+
+
+        int len=length(root);
+
+
+        LinkedListNode<Integer> temp=root;
+        int count=0;
+        while(count<(len-n-1)){
+
+            temp=temp.next;
+
+
+            count++;
+
+
+        }
+
+        LinkedListNode<Integer> small=temp.next;
+        temp.next=null;
+        temp=small;
+        while(temp.next!=null){
+
+            temp=temp.next;
+
+
+        }
+
+        temp.next=root;
+
+        root=small;
+
+        return root;
+
+
+
+    }
+
+    public static LinkedListNode<Integer> appendFastSlowApproach(LinkedListNode<Integer> head, int n) {
+
+
+      if(n==0|| head==null){
+          return head;
+      }
+
+    LinkedListNode<Integer> fast=head;
+      LinkedListNode<Integer>slow=head;
+      LinkedListNode<Integer> init=head;
+      for(int i=0;i<n;i++){
+          fast=fast.next;
+      }
+      while(fast.next!=null){
+          slow=slow.next;
+          fast=fast.next;
+      }
+
+      LinkedListNode<Integer> temp=slow.next;
+      slow.next=null;
+      fast.next=init;
+      head=temp;
+
+      return head;
+
+    }
+}

src/linkedlist/DeleteNnodes.java

@@ -0,0 +1,98 @@
+package linkedlist;
+
+public class DeleteNnodes {
+
+    public static LinkedListNode<Integer> skipMdeleteN(LinkedListNode<Integer> head, int M, int N) {
+
+        if(M==0|| head==null){
+
+            return null;
+        }
+
+        if(N==0){
+            return head;
+        }
+
+        LinkedListNode<Integer> temp=head;
+        LinkedListNode<Integer>curr;
+
+        int i=1;
+        while(temp!=null){
+
+
+            for( i=1;i<M && temp!=null;i++){
+
+                temp=temp.next;
+
+            }
+
+            if(temp==null){
+                return head;
+            }
+
+            curr=temp.next;
+
+            for(i=1;i<=N && curr!=null;i++){
+
+                curr=curr.next;
+
+            }
+
+            temp.next=curr;
+            temp=curr;
+        }
+         return head;
+
+    }
+
+
+    public static LinkedListNode<Integer> skipMdeleteN2(LinkedListNode<Integer> head, int M, int N) {
+
+        if(M==0|| head==null){
+
+            return null;
+        }
+
+        if(N==0){
+            return head;
+        }
+
+        LinkedListNode<Integer> curr=head;
+        LinkedListNode<Integer>temp=null;
+
+
+        while(curr!=null){
+
+            int yes=0;
+            int no=0;
+            while(curr!=null && yes<M){
+
+                if(temp==null){
+                    temp=curr;
+                }
+                else{
+
+                    temp.next=curr;
+                    temp=curr;
+                }
+
+                curr=curr.next;
+                yes+=1;
+
+            }
+
+            while(curr!=null && no<N){
+
+                curr=curr.next;
+                no+=1;
+            }
+
+        }
+
+        if(temp!=null){
+            temp.next=null;
+        }
+        return head;
+
+    }
+}

src/linkedlist/EvenOddLL.java

@@ -0,0 +1,110 @@
+package linkedlist;
+
+public class EvenOddLL {
+
+
+    public static LinkedListNode<Integer> sortEvenOdd(LinkedListNode<Integer> head) {
+
+        if(head==null){
+        return head;
+
+    }
+
+    LinkedListNode<Integer>oh=null;
+    LinkedListNode<Integer>ot=null;
+    LinkedListNode<Integer>eh=null;
+    LinkedListNode<Integer>et=null;
+
+        while(head!=null){
+
+
+        if((head.data%2)!=0){
+
+
+            if(oh==null){
+
+                oh=head;
+                ot=head;
+
+
+            }
+            else{
+
+                ot.next=head;
+                ot=ot.next;
+            }
+        }
+        else{
+
+            if(eh==null){
+
+                eh=head;
+                et=head;
+
+            }
+            else{
+
+                et.next=head;
+                et=et.next;
+
+            }
+
+
+
+
+        }
+
+        head=head.next;
+    }
+
+
+        if(oh==null){
+        et.next=null;
+        return eh;
+    }
+
+        if(eh==null){
+
+        ot.next=null;
+        return oh;
+    }
+
+    ot.next=eh;
+    et.next=null;
+        return oh;
+//         if(oh!=null){
+//         ot.next=null;
+//     }
+//     if(eh!=null){
+//         et.next=null;
+//     }
+
+//     if(oh==null){
+//         return eh;
+//     }
+
+//     if(eh==null){
+//         return oh;
+//     }
+//     else{
+//         ot.next=eh;
+//     }
+
+//     return oh;
+    //write your code here
+//
+//if(oddehead==null){
+//    return evenhead;
+//}
+//else{
+//    oddtail.next=evenhead;
+//}
+//if(evenhead!=null){
+//    eventail.next=null;
+//}
+//
+//return oddhead
+
+
+}
+}

src/linkedlist/FindNode.java

@@ -0,0 +1,24 @@
+package linkedlist;
+
+public class FindNode {
+    public static int helper(LinkedListNode<Integer>head,int n){
+
+
+        if(head==null){
+            return -1;
+        }
+
+        if(head.data==n){
+
+            return 0;
+        }
+
+        int small= helper(head.next,n);
+        if(small==-1){
+            return -1;
+        }
+        return small+1;
+
+    }
+
+}

src/linkedlist/SortLL.java

@@ -18,7 +18,7 @@ public class SortLL {
 
 
 
-    public class Solution {
+
 
         public static DoublyLinkedListNode<Integer>  merge(DoublyLinkedListNode<Integer>head1,DoublyLinkedListNode<Integer>head2){
 
@@ -155,4 +155,4 @@ public static DoublyLinkedListNode<Integer> sorting(DoublyLinkedListNode<Integer
         }
 
     }
-}
+

src/linkedlist/reverseLLByK.java

@@ -0,0 +1,39 @@
+package linkedlist;
+
+public class reverseLLByK {
+
+
+    public static LinkedListNode<Integer> kReverseByRecursion(LinkedListNode<Integer> head, int k) {
+
+
+        if(k==0 || k==1){
+            return head;
+        }
+
+        LinkedListNode<Integer> temp=head;
+        LinkedListNode<Integer> prev=null;
+        LinkedListNode<Integer> fwd=null;
+        if(head==null){
+            return head;
+        }
+
+        int count=0;
+        while(temp!=null && count<k){
+
+            fwd=temp.next;
+            temp.next=prev;
+            prev=temp;
+            temp=fwd;
+            count++;
+        }
+
+        if(fwd!=null){
+            head.next=kReverseByRecursion(fwd,k);
+        }
+
+
+        return prev;
+
+    }
+
+}