Merge pull request ByteByteGoHq#9 from RYMNDK/java-solutions-linked-lists

Java solutions linked lists

Author: Destiny-02

java/Linked Lists/FlattenMultiLevelList.java

@@ -0,0 +1,46 @@
+import DS.MultiLevelListNode;
+
+/*
+    // Definition of MultiLevelListNode:
+    class MultiLevelListNode {
+        public int val;
+        public MultiLevelListNode next;
+        public MultiLevelListNode child;
+        public MultiLevelListNode(int val) { this.val = val; }
+        public MultiLevelListNode(int val, MultiLevelListNode next, MultiLevelListNode child) {
+            this(val);
+            this.next = next;
+            this.child = child;
+        }
+    }
+ */
+
+
+public class FlattenMultiLevelList {
+    public static MultiLevelListNode flattenMultiLevelList(MultiLevelListNode head) {
+        if (head == null) {
+            return null;
+        }
+        MultiLevelListNode tail = head;
+        // Find the tail of the linked list at the first level.
+        while (tail.next != null) {
+            tail = tail.next;
+        }
+        MultiLevelListNode curr = head;
+        // Process each node at the current level. If a node has a child linked list,
+        // append it to the tail and then update the tail to the end of the extended
+        // linked list. Continue until all nodes at the current level are processed.
+        while (curr != null) {
+            if (curr.child != null) {
+                tail.next = curr.child;
+                // Disconnect the child linked list from the current node.
+                curr.child = null;
+                while (tail.next != null) {
+                    tail = tail.next;
+                }
+            }
+            curr = curr.next;
+        }
+        return head;
+    }
+}

java/Linked Lists/LRUCache.java

@@ -0,0 +1,75 @@
+import java.util.HashMap;
+
+class DoublyLinkedListNode {
+    public int key;
+    public int val;
+    public DoublyLinkedListNode next;
+    public DoublyLinkedListNode prev;
+    public DoublyLinkedListNode(int key, int val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+
+public class LRUCache {
+    public int capacity;
+    public HashMap<Integer, DoublyLinkedListNode> cache;
+    public DoublyLinkedListNode head;
+    public DoublyLinkedListNode tail;
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        // A hash map that maps keys to nodes.
+        cache = new HashMap<>();
+        // Initialize the head and tail dummy nodes and connect them to
+        // each other to establish a basic two-node doubly linked list.
+        head = new DoublyLinkedListNode(-1, -1);
+        tail = new DoublyLinkedListNode(-1, -1);
+        head.next = tail;
+        tail.prev = head;
+    }
+
+    public int get(int key) {
+        if (!cache.containsKey(key)) {
+            return -1;
+        }
+        else {
+            // To make this key the most recently used, remove its node and
+            // re-add it to the tail of the linked list.
+            remove(cache.get(key));
+            addToTail(cache.get(key));
+            return cache.get(key).val;
+        }
+    }
+
+    public void put(int key, int val) {
+        // If a node with this key already exists, remove it from the
+        // linked list.
+        if (cache.containsKey(key)) {
+            remove(cache.get(key));
+        }
+        DoublyLinkedListNode node = new DoublyLinkedListNode(key, val);
+        cache.put(key, node);
+        // Remove the least recently used node from the cache if adding
+        // this new node will result in an overflow.
+        if (cache.size() > capacity) {
+            cache.remove(head.next.key);
+            remove(head.next);
+        }
+        addToTail(node);
+    }
+
+    private void addToTail(DoublyLinkedListNode node) {
+        DoublyLinkedListNode prevNode = tail.prev;
+        node.prev = prevNode;
+        node.next = tail;
+        prevNode.next = node;
+        tail.prev = node;
+    }
+
+    private void remove(DoublyLinkedListNode node) {
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+    }
+
+}

java/Linked Lists/LinkedListIntersection.java

@@ -0,0 +1,36 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class LinkedListIntersection {
+    public static ListNode linkedListIntersection(ListNode headA, ListNode headB) {
+        ListNode ptrA = headA;
+        ListNode ptrB = headB;
+        // Traverse through list A with 'ptrA' and list B with 'ptrB'
+        // until they meet.
+        while (ptrA != ptrB) {
+            // Traverse list A -> list B by first traversing 'ptrA' and
+            // then, upon reaching the end of list A, continue the
+            // traversal from the head of list B.
+            ptrA = ptrA == null ? headB : ptrA.next;
+            // Simultaneously, traverse list B -> list A.
+            ptrB = ptrB == null ? headA : ptrB.next;
+        }
+        // At this point, 'ptrA' and 'ptrB' either point to the
+        // intersection node or both are null if the lists do not
+        // intersect. Return either pointer.
+        return ptrA;
+    }
+}

java/Linked Lists/LinkedListReversal.java

@@ -0,0 +1,33 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class LinkedListReversal {
+    public static ListNode linkedListReversal(ListNode head) {
+        ListNode currNode = head;
+        ListNode prevNode = null;
+        // Reverse the direction of each node's pointer until 'currNode'
+        // is null.
+        while (currNode != null) {
+            ListNode nextNode = currNode.next;
+            currNode.next = prevNode;
+            prevNode = currNode;
+            currNode = nextNode;
+        }
+        // 'prevNode' will be pointing at the head of the reversed linked
+        // list.
+        return prevNode;
+    }
+}

java/Linked Lists/LinkedListReversalRecursive.java

@@ -0,0 +1,31 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class LinkedListReversalRecursive {
+    public static ListNode linkedListReversalRecursive(ListNode head) {
+        // Base cases.
+        if (head == null || head.next == null) return head;
+        else {
+            // Recursively reverse the sublist starting from the next node.
+            ListNode newHead = linkedListReversalRecursive(head.next);
+            // Connect the reversed linked list to the head node to fully
+            // reverse the entire linked list.
+            head.next.next = head;
+            head.next = null;
+            return newHead;
+        }
+    }
+}

java/Linked Lists/PalindromicLinkedList.java

@@ -0,0 +1,60 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class PalindromicLinkedList {
+    public static boolean palindromicLinkedList(ListNode head) {
+        // Find the middle of the linked list and then reverse the second half of the
+        // linked list starting at this midpoint.
+        ListNode mid = findMiddle(head);
+        ListNode secondHead = reverseList(mid);
+        // Compare the first half and the reversed second half of the list
+        ListNode ptr1 = head;
+        ListNode ptr2 = secondHead;
+        boolean result = true;
+        while (ptr2 != null) {
+            if (ptr1.val != ptr2.val) {
+                result = false;
+            }
+            ptr1 = ptr1.next;
+            ptr2 = ptr2.next;
+        }
+        return result;
+    }
+
+    // From the 'Reverse Linked List' problem.
+    private static ListNode reverseList(ListNode head) {
+        ListNode currNode = head;
+        ListNode prevNode = null;
+        while (currNode != null) {
+            ListNode nextNode = currNode.next;
+            currNode.next = prevNode;
+            prevNode = currNode;
+            currNode = nextNode;
+        }
+        return prevNode;
+    }
+
+    // From the 'Linked List Midpoint' problem.
+    private static ListNode findMiddle(ListNode head) {
+        ListNode p1 = head;
+        ListNode p2 = head;
+        while (p2 != null && p2.next != null) {
+            p1 = p1.next;
+            p2 = p2.next.next;
+        }
+        return p1;
+    }
+}

java/Linked Lists/RemoveKthLastNode.java

@@ -0,0 +1,44 @@
+import DS.ListNode;
+
+/*
+    // Definition of ListNode:
+    class ListNode {
+        public int val;
+        public ListNode next;
+        public ListNode(int val) { this.val = val; }
+        public ListNode(int val, ListNode next) {
+            this(val);
+            this.next = next;
+        }
+    }
+ */
+
+
+public class RemoveKthLastNode {
+    public static ListNode removeKthLastNode(ListNode head, int k) {
+        // A dummy node to ensure there's a node before 'head' in case we
+        // need to remove the head node.
+        ListNode dummy = new ListNode(-1);
+        dummy.next = head;
+        ListNode trailer = dummy;
+        ListNode leader = head;
+        // Advance 'leader' k steps ahead.
+        for (int i = 0; i < k; i++) {
+            leader = leader.next;
+            // If k is larger than the length of the linked list, no node
+            // needs to be removed.
+            if (leader == null) {
+                return head;
+            }
+        }
+        // Move 'leader' to the end of the linked list, keeping 'trailer'
+        // k nodes behind.
+        while (leader.next != null) {
+            leader = leader.next;
+            trailer = trailer.next;
+        }
+        // Remove the kth node from the end.
+        trailer.next = trailer.next.next;
+        return dummy.next;
+    }
+}