update on linked lists

Author: Blooverh

DataAndAlgoL/Chp3LinkedLists/Problem39.java

@@ -0,0 +1,17 @@
+package DataAndAlgoL.Chp3LinkedLists;
+/*
+ * HOW TO CHECK IS LINKED LIST IS PALINDROME OR NOT
+ * 
+ * ALGORITHM:
+ * 1. GET THE MIDDLE OF THE LINKED LIST 
+ * 2. REVERSE THE SECOND HALF OF THE LINKED LIST
+ * 3.COMPARE THE 1ST HALF WITH THE 2ND HALF
+ * 4. CONSTRUCT THE ORIGINAL LINKED LIST BY REVERSING THE SECOND HALF AGAIN AND ATTACHING IT BACK TO THE 1ST HALF 
+ */
+public class Problem39 {
+    public static void main(String[] args) {
+        
+    }
+
+    
+}

DataAndAlgoL/Chp3LinkedLists/Problem40.java

@@ -0,0 +1,30 @@
+package DataAndAlgoL.Chp3LinkedLists;
+
+/*
+ * Exchange the adjacent elements in a link list 
+ */
+
+public class Problem40 {
+    public static void main(String[] args) {
+        
+    }
+
+    public ListNode exchangeAdjNodes(ListNode head){
+        ListNode temp=null; // to hold another node for swap
+
+        temp.next=head;
+        ListNode prev= temp;
+        ListNode curr= head;
+
+        while( curr != null && curr.next != null){
+            ListNode tmp= curr.next.next;
+            curr.next.next= prev.next;
+            prev.next= curr.next;
+            curr.next= tmp;
+            prev= curr;
+            curr=prev.next;
+        }
+
+        return temp.next;
+    }
+}

LeetCode/Grind169/LinkedLists/LinkedListCycle_141.java

@@ -0,0 +1,33 @@
+package Grind169.LinkedLists;
+
+public class LinkedListCycle_141 {
+    public class ListNode {
+        int val;
+        ListNode next;
+        ListNode() {}
+        ListNode(int val) { this.val = val; }
+        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+    public static boolean hasCycle(ListNode head) {
+        ListNode slow=head;
+        ListNode fast= head;
+        if(head == null){
+            return false;
+        }
+        while(fast.next != null && fast.next.next != null){
+            slow= slow.next;
+            fast=fast.next.next;
+
+            if(slow == fast){
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

LeetCode/Grind169/LinkedLists/Merge2SortedLists_21.java

@@ -0,0 +1,37 @@
+package Grind169.LinkedLists;
+
+public class Merge2SortedLists_21 {
+
+    
+  //Definition for singly-linked list.
+  public class ListNode {
+      int val;
+      ListNode next;
+      ListNode() {}
+      ListNode(int val) { this.val = val; }
+      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+    }
+    public static void main(String[] args) {
+        
+    }
+
+    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+
+        if(l1 ==null ){
+            return l2;
+        }
+
+        if(l2==null){
+            return l1;
+        }
+
+        if(l1.val <l2.val){
+            l1.next=mergeTwoLists(l1.next, l2);
+            return l1;
+        }else{
+            l2.next= mergeTwoLists(l1, l2.next);
+            return l2;
+        }
+
+    }
+}

LeetCode/Grind169/LinkedLists/MidOfLinkedList_876.java

@@ -0,0 +1,29 @@
+package Grind169.LinkedLists;
+
+public class MidOfLinkedList_876 {
+    public class ListNode {
+        int val;
+        ListNode next;
+        ListNode() {}
+        ListNode(int val) { this.val = val; }
+        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+    public static ListNode middleNode(ListNode head) {
+        ListNode slow= head;
+        ListNode fast= head;
+
+        while(fast != null && fast.next != null){
+            slow= slow.next;
+            fast= fast.next.next;
+        }
+
+        return slow;
+
+        
+    }
+}

LeetCode/Grind169/LinkedLists/PalindromeLinkedList_234.java

@@ -0,0 +1,63 @@
+package Grind169.LinkedLists;
+
+public class PalindromeLinkedList_234 {
+    public class ListNode {
+        int val;
+        ListNode next;
+        ListNode() {}
+        ListNode(int val) { this.val = val; }
+        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+    /*\
+     * Use Floyeds cycle to find middle of the list 
+     * reverse second half of the linked list
+     * compare both 1st half and 2nd half 
+     */
+    public static boolean isPalindrome(ListNode head) {
+        //Floyed cycle 
+        ListNode slow =head;
+        ListNode fast =head;
+        // Swap temp nodes 
+        ListNode prev;
+        ListNode temp;
+
+        //Find middle list using Floyed cycle 
+        while(fast != null && fast.next != null){
+            slow=slow.next;
+            fast=fast.next.next;
+        }
+
+        //
+        prev=slow; // prev becomes middle node 
+        slow= slow.next; //slow becomes next node to middle node 
+        prev.next=null; // we assign the prev (mid node) next pointer to null 
+
+        //We swap the nodes in the second half
+        while(slow != null){
+            temp=slow.next;
+            slow.next= prev;
+            prev=slow;
+            slow=temp;
+        }
+
+        //fast goes to first node and slow goes to middle node
+        fast=head;
+        slow=prev;
+        //compare each node fast (from 1st half) and slow node (from 2nd half) check if they are equal
+        while(slow != null){
+            if(fast.val != slow.val){ //if nodes are no equal then list is not a palindrome and returns false
+                return false;
+            }
+
+            fast=fast.next;
+            slow= slow.next;
+        }
+
+        return true;
+    }
+}

LeetCode/Grind169/LinkedLists/ReverseLinkedList_206.java

@@ -0,0 +1,29 @@
+package Grind169.LinkedLists;
+
+public class ReverseLinkedList_206 {
+    public class ListNode {
+        int val;
+        ListNode next;
+        ListNode() {}
+        ListNode(int val) { this.val = val; }
+        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+    public static ListNode reverseList(ListNode head) {
+        ListNode newHead=null;
+
+        while(head != null){
+            ListNode next= head.next;
+            head.next= newHead;
+            newHead=head;
+            head=next;
+        }
+
+        return newHead;
+    }
+      
+}