java 2/19/21/23/24/25

Author: gavinfish

java/_002AddTwoNumbers.java

@@ -0,0 +1,52 @@
+/**
+ * You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+ * You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+ * <p>
+ * Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+ * Output: 7 -> 0 -> 8
+ * <p>
+ * Created by drfish on 16/04/2017.
+ */
+
+/**
+ * Definition for singly-linked list.
+ */
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+    }
+}
+
+public class _002AddTwoNumbers {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode result = new ListNode(0);
+        ListNode cur = result;
+        while (l1 != null || l2 != null) {
+            cur.val += addTwoNodes(l1, l2);
+            if (cur.val >= 10) {
+                cur.val -= 10;
+                cur.next = new ListNode(1);
+            } else {
+                if (l1 != null && l1.next != null || l2 != null && l2.next != null)
+                    cur.next = new ListNode(0);
+            }
+            cur = cur.next;
+            if (l1 != null)
+                l1 = l1.next;
+            if (l2 != null)
+                l2 = l2.next;
+        }
+        return result;
+    }
+
+    private int addTwoNodes(ListNode n1, ListNode n2) {
+        if (n1 == null)
+            return n2.val;
+        if (n2 == null)
+            return n1.val;
+        return n1.val + n2.val;
+    }
+}

java/_019RemoveNthNodeFromEndOfList.java

@@ -0,0 +1,29 @@
+/**
+ * Given a linked list, remove the nth node from the end of list and return its head.
+ * For example,
+ * Given linked list: 1->2->3->4->5, and n = 2.
+ * After removing the second node from the end, the linked list becomes 1->2->3->5.
+ * <p>
+ * Note:
+ * Given n will always be valid.
+ * Try to do this in one pass.
+ * <p>
+ * Created by drfish on 16/04/2017.
+ */
+
+public class _019RemoveNthNodeFromEndOfList {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        ListNode dummy = new ListNode(-1);
+        dummy.next = head;
+        ListNode fast = dummy;
+        ListNode slow = dummy;
+        for (int i = 0; i < n; i++)
+            fast = fast.next;
+        while (fast.next != null) {
+            fast = fast.next;
+            slow = slow.next;
+        }
+        slow.next = slow.next.next;
+        return dummy.next;
+    }
+}

java/_021MergeTwoSortedLists.java

@@ -0,0 +1,26 @@
+/**
+ * Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
+ * <p>
+ * Created by drfish on 16/04/2017.
+ */
+public class _021MergeTwoSortedLists {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode(-1);
+        ListNode head = dummy;
+        while (l1 != null && l2 != null) {
+            if (l1.val < l2.val) {
+                dummy.next = l1;
+                l1 = l1.next;
+            } else {
+                dummy.next = l2;
+                l2 = l2.next;
+            }
+            dummy = dummy.next;
+        }
+        if (l1 == null)
+            dummy.next = l2;
+        if (l2 == null)
+            dummy.next = l1;
+        return head.next;
+    }
+}

java/_023MergekSortedLists.java

@@ -0,0 +1,26 @@
+import java.util.PriorityQueue;
+
+/**
+ * Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+ * <p>
+ * Created by drfish on 16/04/2017.
+ */
+public class _023MergekSortedLists {
+    public ListNode mergeKLists(ListNode[] lists) {
+        PriorityQueue<ListNode> nodesHeap = new PriorityQueue<ListNode>((n1, n2) -> (n1.val - n2.val));
+        for (ListNode node : lists) {
+            if (node != null)
+                nodesHeap.add(node);
+        }
+        ListNode dummy = new ListNode(-1);
+        ListNode head = dummy;
+        while (!nodesHeap.isEmpty()) {
+            ListNode node = nodesHeap.poll();
+            if (node.next != null)
+                nodesHeap.add(node.next);
+            dummy.next = node;
+            dummy = dummy.next;
+        }
+        return head.next;
+    }
+}

java/_024SwapNodesInPairs.java

@@ -0,0 +1,26 @@
+/**
+ * Given a linked list, swap every two adjacent nodes and return its head.
+ * <p>
+ * For example,
+ * Given 1->2->3->4, you should return the list as 2->1->4->3.
+ * <p>
+ * Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.
+ * <p>
+ * Created by drfish on 16/04/2017.
+ */
+public class _024SwapNodesInPairs {
+    public ListNode swapPairs(ListNode head) {
+        if (head == null || head.next == null)
+            return head;
+        ListNode dummy = new ListNode(-1);
+        dummy.next = head;
+        for (ListNode prev = dummy, cur = prev.next, next = cur.next;
+             next != null;
+             prev = cur, cur = cur.next, next = cur != null ? cur.next : null) {
+            prev.next = next;
+            cur.next = next.next;
+            next.next = cur;
+        }
+        return dummy.next;
+    }
+}

java/_25ReverNodesInkGroup.java

@@ -0,0 +1,45 @@
+/**
+ * Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
+ * <p>
+ * k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
+ * <p>
+ * You may not alter the values in the nodes, only nodes itself may be changed.
+ * <p>
+ * Only constant memory is allowed.
+ * <p>
+ * For example,
+ * Given this linked list: 1->2->3->4->5
+ * <p>
+ * For k = 2, you should return: 2->1->4->3->5
+ * <p>
+ * For k = 3, you should return: 3->2->1->4->5
+ * <p>
+ * Created by drfish on 16/04/2017.
+ */
+public class _25ReverNodesInkGroup {
+    public ListNode reverseKGroup(ListNode head, int k) {
+        if (head == null || k <= 1)
+            return head;
+        ListNode dummy = new ListNode(-1);
+        dummy.next = head;
+        for (ListNode prev = dummy, end = head; end != null; end = prev.next) {
+            for (int i = 1; i < k && end != null; i++)
+                end = end.next;
+            if (end == null)
+                break;
+            prev = reverse(prev, prev.next, end);
+        }
+        return dummy.next;
+    }
+
+    private ListNode reverse(ListNode prev, ListNode start, ListNode end) {
+        ListNode endNext = end.next;
+        for (ListNode p = start, cur = p.next, next = cur.next;
+             cur != endNext;
+             p = cur, cur = next, next = next != null ? next.next : null)
+            cur.next = p;
+        start.next = endNext;
+        prev.next = end;
+        return start;
+    }
+}