OddEventLinkedList,TernarySumClosest

Author: JoshuaJiangFD

src/main/java/joshua/leetcode/array/twopointers/TernarySumClosest.java

@@ -0,0 +1,60 @@
+package joshua.leetcode.array.twopointers;
+
+import java.util.Arrays;
+
+/**
+ * 16. 3Sum Closest
+ * <p/>
+ * <a href="https://leetcode.com/problems/3sum-closest/">leetcode link</a>
+ *
+ * @author Joshua.Jiang on 2016/5/21.
+ */
+public abstract class TernarySumClosest {
+
+    /**
+     * Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.
+     * <p/>
+     * For example, given array S = {-1 2 1 -4}, and target = 1.
+     * <p/>
+     * The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+     *
+     * @param nums   the array
+     * @param target the target value
+     * @return the closest sum for three elements from <code>nums</code>
+     */
+    public abstract int threeSumClosest(int[] nums, int target);
+
+
+    /**
+     * 一个从 {@link joshua.leetcode.array.TernarySum} 的解法的变种。
+     * 不同的在于判断two pointers中如何移动left pointer和right pointer。
+     */
+    public static class Solution1 extends TernarySumClosest {
+
+        @Override
+        public int threeSumClosest(int[] nums, int target) {
+            int closestSum = 0;
+            int closestGap = Integer.MAX_VALUE;
+            Arrays.sort(nums);
+            for (int i = 0; i < nums.length - 2; i++) {
+                int leftPointer = i + 1;
+                int rightPointer = nums.length - 1;
+                while (leftPointer < rightPointer) {
+                    int sum = nums[i] + nums[leftPointer] + nums[rightPointer];
+                    if (Math.abs(sum - target) < closestGap) {
+                        closestSum = sum;
+                        closestGap = Math.abs(sum - target);
+                    }
+                    if(sum < target) {
+                        leftPointer ++;
+                    } else {
+                        rightPointer --;
+                    }
+                }
+            }
+            return closestSum;
+        }
+    }
+}
+
+

src/main/java/joshua/leetcode/linkedlist/ListNode.java

@@ -1,25 +1,41 @@
 package joshua.leetcode.linkedlist;
 
 public class ListNode {
-	
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) return true;
+		if (o == null || getClass() != o.getClass()) return false;
+
+		ListNode listNode = (ListNode) o;
+
+		if (val != listNode.val) return false;
+		if (next != null ? !next.equals(listNode.next) : listNode.next != null) return false;
+
+		return true;
+	}
+
+	@Override
+	public int hashCode() {
+		int result = val;
+		result = 31 * result + (next != null ? next.hashCode() : 0);
+		return result;
+	}
+
 	public int val;
 	public ListNode next;
 
 	public 	ListNode(int x) {
 		val = x;
 		next = null;
 	}
-	
-	
 
 	public ListNode(int val, ListNode next) {
 		super();
 		this.val = val;
 		this.next = next;
 	}
 
-
-
 	public static ListNode buildList(int[] vals){
 		if(vals==null||vals.length==0)
 			return null;

src/main/java/joshua/leetcode/linkedlist/OddEvenLinkedList.java

@@ -0,0 +1,38 @@
+package joshua.leetcode.linkedlist;
+
+/**
+ * 328. Odd Even Linked List<br/>
+ *
+ * <a href="https://leetcode.com/problems/odd-even-linked-list/">leetcode link</a>
+ *
+ * @author Joshua.Jiang on 2016/5/22.
+ */
+public abstract class OddEvenLinkedList {
+
+    public abstract ListNode oddEvenList(ListNode head);
+
+    public static class Solution1 extends OddEvenLinkedList {
+
+        @Override
+        public ListNode oddEvenList(ListNode head) {
+            if (head == null) {
+                return head;
+            }
+            ListNode lastOddNode = head;
+            while (lastOddNode.next != null && lastOddNode.next.next != null) {
+                lastOddNode = lastOddNode.next.next;
+            }
+            ListNode nextOddNode = head;
+            ListNode posToInsert = lastOddNode;
+            while(nextOddNode != lastOddNode) {
+                ListNode evenNodeToMove = nextOddNode.next;
+                nextOddNode.next = nextOddNode.next.next;
+                nextOddNode = nextOddNode.next;
+                evenNodeToMove.next = posToInsert.next;
+                posToInsert.next = evenNodeToMove;
+                posToInsert = evenNodeToMove;
+            }
+            return head;
+        }
+    }
+}

src/test/java/joshua/leetcode/array/twopointers/TernarySumClosestTest.java

@@ -0,0 +1,45 @@
+package joshua.leetcode.array.twopointers;
+
+import com.google.common.collect.Maps;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class TernarySumClosestTest {
+
+    private TernarySumClosest solution;
+
+    private Map<Param, Integer> cases = Maps.newHashMap();
+
+    @Before
+    public void setUp() {
+        cases.put(new Param(new int[]{0,0,0},1), 0);
+        cases.put(new Param(new int[]{-1,2,1,4},1), 2);
+        cases.put(new Param(new int[]{-1,0,1,2,-1,-4},0), 0);
+        cases.put(new Param(new int[]{-1,2,1,-4},1), 2);
+        cases.put(new Param(new int[]{1,1,-1,-1,3},-1), -1);
+        cases.put(new Param(new int[]{4,0,5,-5,3,3,0,-4,-5},-2), -2);
+    }
+
+    @Test
+    public void testSolution1() {
+        solution = new TernarySumClosest.Solution1();
+        for(Param param : cases.keySet()) {
+            assertEquals((int)cases.get(param), solution.threeSumClosest(param.nums,param.target));
+        }
+    }
+
+    class Param {
+        int[] nums;
+        int target;
+
+        public Param(int[] nums, int target) {
+            this.nums = nums;
+            this.target = target;
+        }
+    }
+
+}

src/test/java/joshua/leetcode/linkedlist/OddEvenLinkedListTest.java

@@ -0,0 +1,35 @@
+package joshua.leetcode.linkedlist;
+
+import com.google.common.collect.Maps;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class OddEvenLinkedListTest {
+
+    private Map<ListNode, ListNode> cases = Maps.newHashMap();
+
+    private OddEvenLinkedList solution;
+
+    @Before
+    public void setUp() {
+//        ListNode origin = ListNode.buildList(new int[]{1,2,3,4,5});
+//        ListNode transferred = ListNode.buildList(new int[]{1,3,5,2,4});
+        ListNode origin = ListNode.buildList(new int[]{1, 2});
+        ListNode transferred = ListNode.buildList(new int[]{1, 2});
+        cases.put(origin, transferred);
+    }
+
+    @Test
+    public void testSolution1() {
+        solution = new OddEvenLinkedList.Solution1();
+        for (ListNode param : cases.keySet()) {
+            ListNode result = solution.oddEvenList(param);
+            assertEquals(cases.get(param), result);
+        }
+    }
+
+}