Linked List

Author: turingfly

src/chapter02LinkedList/DeleteMiddleNode.java

@@ -0,0 +1,29 @@
+package chapter02LinkedList;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 19, 2017 9:33:21 PM
+ * 
+ *         Problem: Implement an algorithm to delete a node in the middle (i.e.,
+ *         any node but the first and last node, not necessarily the exact
+ *         middle) of a singly linked list, given only access to that node.
+ *         
+ *         EXAMPLE lnput:the node c from the linked list a->b->c->d->e->f
+ *         Result: nothing is returned, but the new linked list looks like
+ *         a->b->d->e->f
+ *
+ *         Solution:
+ *
+ */
+public class DeleteMiddleNode {
+	public boolean deleteNode(ListNode node) {
+		if (node == null || node.next == null) {
+			return false;
+		}
+		ListNode nextNode = node.next;
+		node.val = nextNode.val;
+		node.next = nextNode.next;
+		return true;
+	}
+}

src/chapter02LinkedList/ListNode.java

@@ -0,0 +1,10 @@
+package chapter02LinkedList;
+
+public class ListNode {
+	int val;
+	ListNode next;
+
+	public ListNode(int val) {
+		this.val = val;
+	}
+}

src/chapter02LinkedList/Partition.java

@@ -0,0 +1,38 @@
+package chapter02LinkedList;
+
+/**
+ * 
+ * @author chengfeili
+ * Jun 19, 2017 9:38:52 PM
+ * 
+ * Problem: Given a linked list and a value x, partition it such that all nodes
+ * less than x come before nodes greater than or equal to x.
+ * You should preserve the original relative order of the nodes in each of the
+ * two partitions.
+ * For example, Given 1->4->3->2->5->2 and x = 3, return 1->2->2->4->3->5.
+ * 
+ *
+ */
+public class Partition {
+	public ListNode partition(ListNode head, int x) {
+		ListNode less = new ListNode(0);
+		ListNode greater = new ListNode(0);
+		ListNode l1 = less;
+		ListNode l2 = greater;
+		while (head != null) {
+			if (head.val < x) {
+				l1.next = head;
+				l1 = head;
+			} else {
+				l2.next = head;
+				l2 = head;
+			}
+			head = head.next;
+		}
+		// make sure there is no cycle.
+		// 3->4->1->2. 4->2 change to 4->null
+		l2.next = null;
+		l1.next = greater.next;
+		return less.next;
+	}
+}

src/chapter02LinkedList/RemoveDuplicates.java

@@ -0,0 +1,66 @@
+package chapter02LinkedList;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 19, 2017 7:40:58 PM
+ * 
+ *         Problem: Write code to remove duplicates from an unsorted linked
+ *         list. 1 -> 2 -> 1 ===> 1 -> 2 
+ *         Solution:
+ *
+ */
+public class RemoveDuplicates {
+	// method 1: with temporary buffer.
+	public ListNode deleteDups(ListNode node) {
+		if (node == null) {
+			return null;
+		}
+		ListNode head = node;
+		Set<Integer> set = new HashSet<>();
+		while (node.next != null) {
+			if (set.contains(node.next.val)) {
+				node.next = node.next.next;
+			} else {
+				set.add(node.val);
+				node = node.next;
+			}
+		}
+		return head;
+	}
+
+	// method 2: without temporary buffer.
+	// two pointers. time O(N2), space O(1)
+	public ListNode deleteDups2(ListNode node) {
+		ListNode head = node;
+		while (node != null) {
+			ListNode runner = node;
+			while (runner.next != null) {
+				if (runner.next.val == node.val) {
+					runner.next = runner.next.next;
+				} else {
+					runner = runner.next;
+				}
+			}
+			node = node.next;
+		}
+		return head;
+	}
+
+	public static void main(String[] args) {
+		ListNode n1 = new ListNode(1);
+		ListNode n2 = new ListNode(2);
+		ListNode n3 = new ListNode(1);
+		n1.next = n2;
+		n2.next = n3;
+		RemoveDuplicates rmd = new RemoveDuplicates();
+		ListNode node = rmd.deleteDups(n1);
+		while (node != null) {
+			System.out.print(node.val + " ");
+			node = node.next;
+		}
+	}
+}

src/chapter02LinkedList/ReturnKthToLast.java

@@ -0,0 +1,79 @@
+package chapter02LinkedList;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 19, 2017 8:38:57 PM
+ * 
+ *         Problem: Implement an algorithm to find the kth to last element of a
+ *         singly linked list. 
+ *         1 -> 2 -> 3 3th to last node is 1 
+ *         
+ *         Solution:
+ *
+ */
+class Index {
+	public int value = 0;
+}
+
+public class ReturnKthToLast {
+
+	// method 1: recursion; Space O(N)
+	public int printKthToLast(ListNode head, int k) {
+		if (head == null) {
+			return 0;
+		}
+		int index = printKthToLast(head.next, k) + 1;
+		if (index == k) {
+			System.out.println(k + "th to last node is " + head.val);
+		}
+		return index;
+	}
+
+	// method 2: Wrapper class, recursion; Space O(N)
+	public ListNode kthToLast(ListNode head, int k) {
+		Index idx = new Index();
+		return helper(head, k, idx);
+	}
+
+	private ListNode helper(ListNode head, int k, Index idx) {
+		if (head == null) {
+			return null;
+		}
+		ListNode node = helper(head.next, k, idx);
+		idx.value = idx.value + 1;
+		if (idx.value == k) {
+			return head;
+		}
+		return node;
+	}
+
+	// mehtod 3: iteration Time: O(N), Space O(1)
+	public ListNode kthToLast3(ListNode node, int k) {
+		ListNode left = node;
+		ListNode right = node;
+		for (int i = 0; i < k; i++) {
+			if (right == null) {
+				return null;
+			}
+			System.out.println("==" + right.val);
+			right = right.next;
+		}
+		while (right != null) {
+			right = right.next;
+			left = left.next;
+		}
+		return left;
+	}
+
+	public static void main(String[] args) {
+		ListNode n1 = new ListNode(1);
+		ListNode n2 = new ListNode(2);
+		ListNode n3 = new ListNode(3);
+		n1.next = n2;
+		n2.next = n3;
+		ReturnKthToLast rmd = new ReturnKthToLast();
+		// rmd.printKthToLast(n1, 3);
+		System.out.println(rmd.kthToLast3(n1, 1).val);
+	}
+}