Add Linked List, Stack and Queue solutions

Author: teamlead

README.md

@@ -88,6 +88,15 @@ leetcode-75-solutions-java/
 | Hash Map / Set | [Unique Number of Occurrences](https://leetcode.com/problems/unique-number-of-occurrences/)                                                       | [UniqueOccurrenceChecker.java](src/hash_map_set/UniqueOccurrenceChecker.java)               | Easy       |
 | Hash Map / Set | [Determine if Two Strings Are Close](https://leetcode.com/problems/determine-if-two-strings-are-close/)                                           | [StringCloseChecker.java](src/hash_map_set/StringCloseChecker.java)                         | Medium     |
 | Hash Map / Set | [Equal Row and Column Pairs](https://leetcode.com/problems/equal-row-and-column-pairs/)                                                           | [MatrixPairs.java](src/hash_map_set/MatrixPairs.java)                                       | Medium     |
+| Stack          | [Decode String](https://leetcode.com/problems/decode-string/)                                                                                     | [StringDecoder.java](src/stack/StringDecoder.java)                                          | Medium     |
+| Stack          | [Asteroid Collision](https://leetcode.com/problems/asteroid-collision/)                                                                           | [AsteroidCollisionSimulator.java](src/stack/AsteroidCollisionSimulator.java)                | Medium     |
+| Stack          | [Removing Stars From a String](https://leetcode.com/problems/removing-stars-from-a-string/)                                                       | [StarStringProcessor.java](src/stack/StarStringProcessor.java)                              | Medium     |
+| Queue          | [Number of Recent Calls](https://leetcode.com/problems/number-of-recent-calls/)                                                                   | [RecentCounter.java](src/queue/RecentCounter.java)                                          | Easy       |
+| Queue          | [Dota2 Senate](https://leetcode.com/problems/dota2-senate/)                                                                                       | [SenateDecisionSimulator.java](src/queue/SenateDecisionSimulator.java)                      | Medium     |
+| Linked List    | [Delete the Middle Node of a Linked List](https://leetcode.com/problems/delete-the-middle-node-of-a-linked-list/)                                 | [LinkedListProcessor.java](src/linked_list/LinkedListProcessor.java)                        | Medium     |
+| Linked List    | [Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/)                                                                       | [OddEvenLinkedListTransformer.java](src/linked_list/OddEvenLinkedListTransformer.java)      | Medium     |
+| Linked List    | [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)                                                                         | [LinkedListReverser.java](src/linked_list/LinkedListReverser.java)                          | Easy       |
+| Linked List    | [Maximum Twin Sum of a Linked List](https://leetcode.com/problems/maximum-twin-sum-of-a-linked-list/)                                             | [MaxTwinSumCalculator.java](src/linked_list/MaxTwinSumCalculator.java)                      | Medium     |
 | ...            | ...                                                                                                                                               | ...                                                                                         | ...        |
 | Trie           | [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree)                                                          | [PrefixTrie.java](src/trie/PrefixTrie.java)                                                 | Medium     |
 | Trie           | [Search Suggestions System](https://leetcode.com/problems/search-suggestions-system)                                                              | [SearchSuggestionsSystem.java](src/trie/SearchSuggestionsSystem.java)                       | Medium     |

src/linked_list/LinkedListProcessor.java

@@ -0,0 +1,66 @@
+package linked_list;
+
+public class LinkedListProcessor {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int val) {
+            this.val = val;
+        }
+    }
+
+    public ListNode deleteMiddle(ListNode head) {
+        if (head == null || head.next == null) return null;
+
+        ListNode fast = head, slow = head, prev = null;
+
+        while (fast != null && fast.next != null) {
+            fast = fast.next.next;
+            prev = slow;
+            slow = slow.next;
+        }
+
+        prev.next = slow.next;
+
+        return head;
+    }
+
+    private static ListNode arrayToList(int[] arr) {
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+        for (int num : arr) {
+            tail.next = new ListNode(num);
+            tail = tail.next;
+        }
+        return dummy.next;
+    }
+
+    private static boolean areListsEqual(ListNode l1, ListNode l2) {
+        while (l1 != null && l2 != null) {
+            if (l1.val != l2.val) return false;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+        return l1 == null && l2 == null;
+    }
+
+    public static void main(String[] args) {
+        LinkedListProcessor processor = new LinkedListProcessor();
+
+        ListNode head1 = arrayToList(new int[]{1,3,4,7,1,2,6});
+        ListNode expected1 = arrayToList(new int[]{1,3,4,1,2,6});
+        assert areListsEqual(processor.deleteMiddle(head1), expected1) : "Test case 1 failed";
+
+        ListNode head2 = arrayToList(new int[]{1,2,3,4});
+        ListNode expected2 = arrayToList(new int[]{1,2,4});
+        assert areListsEqual(processor.deleteMiddle(head2), expected2) : "Test case 2 failed";
+
+        ListNode head3 = arrayToList(new int[]{2,1});
+        ListNode expected3 = arrayToList(new int[]{2});
+        assert areListsEqual(processor.deleteMiddle(head3), expected3) : "Test case 3 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/linked_list/LinkedListReverser.java

@@ -0,0 +1,64 @@
+package linked_list;
+
+
+public class LinkedListReverser {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int val) {
+            this.val = val;
+        }
+    }
+
+    public ListNode reverseList(ListNode head) {
+        ListNode prev = null;
+        ListNode current = head;
+
+        while (current != null) {
+            ListNode next = current.next;
+            current.next = prev;
+            prev = current;
+            current = next;
+        }
+        return prev;
+    }
+
+    private static ListNode arrayToList(int[] arr) {
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+        for (int num : arr) {
+            tail.next = new ListNode(num);
+            tail = tail.next;
+        }
+        return dummy.next;
+    }
+
+    private static boolean areListsEqual(ListNode l1, ListNode l2) {
+        while (l1 != null && l2 != null) {
+            if (l1.val != l2.val) return false;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+        return l1 == null && l2 == null;
+    }
+
+    public static void main(String[] args) {
+        LinkedListReverser reverser = new LinkedListReverser();
+
+        ListNode head1 = arrayToList(new int[]{1,2,3,4,5});
+        ListNode expected1 = arrayToList(new int[]{5,4,3,2,1});
+        assert areListsEqual(reverser.reverseList(head1), expected1) : "Test case 1 failed";
+
+        ListNode head2 = arrayToList(new int[]{1,2});
+        ListNode expected2 = arrayToList(new int[]{2,1});
+        assert areListsEqual(reverser.reverseList(head2), expected2) : "Test case 2 failed";
+
+        ListNode head3 = arrayToList(new int[]{});
+        ListNode expected3 = arrayToList(new int[]{});
+        assert areListsEqual(reverser.reverseList(head3), expected3) : "Test case 3 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/linked_list/MaxTwinSumCalculator.java

@@ -0,0 +1,67 @@
+package linked_list;
+
+public class MaxTwinSumCalculator {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int val) {
+            this.val = val;
+        }
+    }
+
+    public int pairSum(ListNode head) {
+        ListNode slow = head, fast = head;
+        int maxSum = 0;
+
+        // Finding the middle of the list
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+
+        // Reversing the second half of the list
+        ListNode nextNode, prev = null;
+        while (slow != null) {
+            nextNode = slow.next;
+            slow.next = prev;
+            prev = slow;
+            slow = nextNode;
+        }
+
+        // Calculating max twin sum
+        while (prev != null) {
+            maxSum = Math.max(maxSum, head.val + prev.val);
+            head = head.next;
+            prev = prev.next;
+        }
+
+        return maxSum;
+    }
+
+    private static ListNode arrayToList(int[] arr) {
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+        for (int num : arr) {
+            tail.next = new ListNode(num);
+            tail = tail.next;
+        }
+        return dummy.next;
+    }
+
+    public static void main(String[] args) {
+        MaxTwinSumCalculator calculator = new MaxTwinSumCalculator();
+
+        ListNode head1 = arrayToList(new int[]{5,4,2,1});
+        assert calculator.pairSum(head1) == 6 : "Test case 1 failed";
+
+        ListNode head2 = arrayToList(new int[]{4,2,2,3});
+        assert calculator.pairSum(head2) == 7 : "Test case 2 failed";
+
+        ListNode head3 = arrayToList(new int[]{1,100000});
+        assert calculator.pairSum(head3) == 100001 : "Test case 3 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/linked_list/OddEvenLinkedListTransformer.java

@@ -0,0 +1,64 @@
+package linked_list;
+
+public class OddEvenLinkedListTransformer {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int val) {
+            this.val = val;
+        }
+    }
+
+    public ListNode oddEvenList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+
+        ListNode odd = head, even = head.next, evenHead = even;
+
+        while (even != null && even.next != null) {
+            odd.next = odd.next.next;
+            even.next = even.next.next;
+            odd = odd.next;
+            even = even.next;
+        }
+
+        odd.next = evenHead;
+        return head;
+    }
+
+    private static ListNode arrayToList(int[] arr) {
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+        for (int num : arr) {
+            tail.next = new ListNode(num);
+            tail = tail.next;
+        }
+        return dummy.next;
+    }
+
+    private static boolean areListsEqual(ListNode l1, ListNode l2) {
+        while (l1 != null && l2 != null) {
+            if (l1.val != l2.val) return false;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+        return l1 == null && l2 == null;
+    }
+
+    public static void main(String[] args) {
+        OddEvenLinkedListTransformer transformer = new OddEvenLinkedListTransformer();
+
+        ListNode head1 = arrayToList(new int[]{1,2,3,4,5});
+        ListNode expected1 = arrayToList(new int[]{1,3,5,2,4});
+        assert areListsEqual(transformer.oddEvenList(head1), expected1) : "Test case 1 failed";
+
+        ListNode head2 = arrayToList(new int[]{2,1,3,5,6,4,7});
+        ListNode expected2 = arrayToList(new int[]{2,3,6,7,1,5,4});
+        assert areListsEqual(transformer.oddEvenList(head2), expected2) : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}

src/queue/RecentCounter.java

@@ -0,0 +1,38 @@
+package queue;
+
+import java.util.*;
+
+class RecentCounter {
+
+    Queue<Integer> queue;
+
+    public RecentCounter() {
+        queue = new LinkedList<>();
+    }
+
+    public int ping(int t) {
+        queue.offer(t);
+        while (queue.peek() < t - 3000) {
+            queue.poll();
+        }
+        return queue.size();
+    }
+
+
+    public static void main(String[] args) {
+        RecentCounter counter = new RecentCounter();
+
+        // Test cases
+        boolean passed = true;
+        passed &= counter.ping(1) == 1;
+        passed &= counter.ping(100) == 2;
+        passed &= counter.ping(3001) == 3;
+        passed &= counter.ping(3002) == 3;
+
+        if (passed) {
+            System.out.println("All test cases passed!");
+        } else {
+            System.out.println("Some test cases failed.");
+        }
+    }
+}

src/queue/SenateDecisionSimulator.java

@@ -0,0 +1,42 @@
+package queue;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class SenateDecisionSimulator {
+
+    public String predictPartyVictory(String senate) {
+        Queue<Integer> radiant = new LinkedList<>();
+        Queue<Integer> dire = new LinkedList<>();
+        int n = senate.length();
+
+        for (int i = 0; i < n; i++) {
+            if (senate.charAt(i) == 'R') {
+                radiant.offer(i);
+            } else {
+                dire.offer(i);
+            }
+        }
+
+        while (!radiant.isEmpty() && !dire.isEmpty()) {
+            int rIndex = radiant.poll();
+            int dIndex = dire.poll();
+            if (rIndex < dIndex) {
+                radiant.offer(rIndex + n);
+            } else {
+                dire.offer(dIndex + n);
+            }
+        }
+
+        return radiant.isEmpty() ? "Dire" : "Radiant";
+    }
+
+    public static void main(String[] args) {
+        SenateDecisionSimulator simulator = new SenateDecisionSimulator();
+
+        assert simulator.predictPartyVictory("RD").equals("Radiant") : "Test case 1 failed";
+        assert simulator.predictPartyVictory("RDD").equals("Dire") : "Test case 2 failed";
+
+        System.out.println("All test cases passed!");
+    }
+}