add public 04

src/class04/Code01_ReverseList.java

@@ -0,0 +1,218 @@
+package class04;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Code01_ReverseList {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int data) {
+			value = data;
+		}
+	}
+
+	public static class DoubleNode {
+		public int value;
+		public DoubleNode last;
+		public DoubleNode next;
+
+		public DoubleNode(int data) {
+			value = data;
+		}
+	}
+
+	public static Node reverseLinkedList(Node head) {
+		Node pre = null;
+		Node next = null;
+		while (head != null) {
+			next = head.next;
+			head.next = pre;
+			pre = head;
+			head = next;
+		}
+		return pre;
+	}
+
+	public static DoubleNode reverseDoubleList(DoubleNode head) {
+		DoubleNode pre = null;
+		DoubleNode next = null;
+		while (head != null) {
+			next = head.next;
+			head.next = pre;
+			head.last = next;
+			pre = head;
+			head = next;
+		}
+		return pre;
+	}
+
+	public static Node testReverseLinkedList(Node head) {
+		if (head == null) {
+			return null;
+		}
+		ArrayList<Node> list = new ArrayList<>();
+		while (head != null) {
+			list.add(head);
+			head = head.next;
+		}
+		list.get(0).next = null;
+		int N = list.size();
+		for (int i = 1; i < N; i++) {
+			list.get(i).next = list.get(i - 1);
+		}
+		return list.get(N - 1);
+	}
+
+	public static DoubleNode testReverseDoubleList(DoubleNode head) {
+		if (head == null) {
+			return null;
+		}
+		ArrayList<DoubleNode> list = new ArrayList<>();
+		while (head != null) {
+			list.add(head);
+			head = head.next;
+		}
+		list.get(0).next = null;
+		DoubleNode pre = list.get(0);
+		int N = list.size();
+		for (int i = 1; i < N; i++) {
+			DoubleNode cur = list.get(i);
+			cur.last = null;
+			cur.next = pre;
+			pre.last = cur;
+			pre = cur;
+		}
+		return list.get(N - 1);
+	}
+
+	// for test
+	public static Node generateRandomLinkedList(int len, int value) {
+		int size = (int) (Math.random() * (len + 1));
+		if (size == 0) {
+			return null;
+		}
+		size--;
+		Node head = new Node((int) (Math.random() * (value + 1)));
+		Node pre = head;
+		while (size != 0) {
+			Node cur = new Node((int) (Math.random() * (value + 1)));
+			pre.next = cur;
+			pre = cur;
+			size--;
+		}
+		return head;
+	}
+
+	// for test
+	public static DoubleNode generateRandomDoubleList(int len, int value) {
+		int size = (int) (Math.random() * (len + 1));
+		if (size == 0) {
+			return null;
+		}
+		size--;
+		DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
+		DoubleNode pre = head;
+		while (size != 0) {
+			DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
+			pre.next = cur;
+			cur.last = pre;
+			pre = cur;
+			size--;
+		}
+		return head;
+	}
+
+	// for test
+	public static List<Integer> getLinkedListOriginOrder(Node head) {
+		List<Integer> ans = new ArrayList<>();
+		while (head != null) {
+			ans.add(head.value);
+			head = head.next;
+		}
+		return ans;
+	}
+
+	// for test
+	public static boolean checkLinkedListReverse(List<Integer> origin, Node head) {
+		for (int i = origin.size() - 1; i >= 0; i--) {
+			if (!origin.get(i).equals(head.value)) {
+				return false;
+			}
+			head = head.next;
+		}
+		return true;
+	}
+
+	// for test
+	public static List<Integer> getDoubleListOriginOrder(DoubleNode head) {
+		List<Integer> ans = new ArrayList<>();
+		while (head != null) {
+			ans.add(head.value);
+			head = head.next;
+		}
+		return ans;
+	}
+
+	// for test
+	public static boolean checkDoubleListReverse(List<Integer> origin, DoubleNode head) {
+		DoubleNode end = null;
+		for (int i = origin.size() - 1; i >= 0; i--) {
+			if (!origin.get(i).equals(head.value)) {
+				return false;
+			}
+			end = head;
+			head = head.next;
+		}
+		for (int i = 0; i < origin.size(); i++) {
+			if (!origin.get(i).equals(end.value)) {
+				return false;
+			}
+			end = end.last;
+		}
+		return true;
+	}
+
+	// for test
+	public static void main(String[] args) {
+		int len = 50;
+		int value = 100;
+		int testTime = 100000;
+		System.out.println("test begin!");
+		for (int i = 0; i < testTime; i++) {
+			Node node1 = generateRandomLinkedList(len, value);
+			List<Integer> list1 = getLinkedListOriginOrder(node1);
+			node1 = reverseLinkedList(node1);
+			if (!checkLinkedListReverse(list1, node1)) {
+				System.out.println("Oops1!");
+			}
+
+			Node node2 = generateRandomLinkedList(len, value);
+			List<Integer> list2 = getLinkedListOriginOrder(node2);
+			node2 = testReverseLinkedList(node2);
+			if (!checkLinkedListReverse(list2, node2)) {
+				System.out.println("Oops2!");
+			}
+
+			DoubleNode node3 = generateRandomDoubleList(len, value);
+			List<Integer> list3 = getDoubleListOriginOrder(node3);
+			node3 = reverseDoubleList(node3);
+			if (!checkDoubleListReverse(list3, node3)) {
+				System.out.println("Oops3!");
+			}
+
+			DoubleNode node4 = generateRandomDoubleList(len, value);
+			List<Integer> list4 = getDoubleListOriginOrder(node4);
+			node4 = reverseDoubleList(node4);
+			if (!checkDoubleListReverse(list4, node4)) {
+				System.out.println("Oops4!");
+			}
+
+		}
+		System.out.println("test finish!");
+
+	}
+
+}

src/class04/Code01_LinkedListToQueueAndStack.java → src/class04/Code02_LinkedListToQueueAndStack.java

@@ -4,7 +4,7 @@
 import java.util.Queue;
 import java.util.Stack;
 
-public class Code01_LinkedListToQueueAndStack {
+public class Code02_LinkedListToQueueAndStack {
 
 	public static class Node<V> {
 		public V value;

src/class04/Code02_DoubleLinkedListToDeque.java → src/class04/Code03_DoubleLinkedListToDeque.java

@@ -3,7 +3,7 @@
 import java.util.Deque;
 import java.util.LinkedList;
 
-public class Code02_DoubleLinkedListToDeque {
+public class Code03_DoubleLinkedListToDeque {
 
 	public static class Node<V> {
 		public V value;

src/class04/Code04_ReverseNodesInKGroup.java

@@ -0,0 +1,55 @@
+package class04;
+
+// 测试链接：https://leetcode.com/problems/reverse-nodes-in-k-group/
+public class Code04_ReverseNodesInKGroup {
+
+	// 不要提交这个类
+	public static class ListNode {
+		public int val;
+		public ListNode next;
+	}
+
+	public static ListNode reverseKGroup(ListNode head, int k) {
+		ListNode start = head;
+		ListNode end = getKGroupEnd(start, k);
+		if (end == null) {
+			return head;
+		}
+		head = end;
+		reverse(start, end);
+		ListNode lastEnd = start;
+		while (lastEnd.next != null) {
+			start = lastEnd.next;
+			end = getKGroupEnd(start, k);
+			if (end == null) {
+				return head;
+			}
+			reverse(start, end);
+			lastEnd.next = end;
+			lastEnd = start;
+		}
+		return head;
+	}
+
+	public static ListNode getKGroupEnd(ListNode start, int k) {
+		while (--k != 0 && start != null) {
+			start = start.next;
+		}
+		return start;
+	}
+
+	public static void reverse(ListNode start, ListNode end) {
+		end = end.next;
+		ListNode pre = null;
+		ListNode cur = start;
+		ListNode next = null;
+		while (cur != end) {
+			next = cur.next;
+			cur.next = pre;
+			pre = cur;
+			cur = next;
+		}
+		start.next = end;
+	}
+
+}

src/class04/Code05_AddTwoNumbers.java

@@ -0,0 +1,61 @@
+package class04;
+
+// 测试链接：https://leetcode.com/problems/add-two-numbers/
+public class Code05_AddTwoNumbers {
+
+	// 不要提交这个类
+	public static class ListNode {
+		public int val;
+		public ListNode next;
+
+		public ListNode(int val) {
+			this.val = val;
+		}
+
+		public ListNode(int val, ListNode next) {
+			this.val = val;
+			this.next = next;
+		}
+	}
+
+	public static ListNode addTwoNumbers(ListNode head1, ListNode head2) {
+		int len1 = listLength(head1);
+		int len2 = listLength(head2);
+		ListNode l = len1 >= len2 ? head1 : head2;
+		ListNode s = l == head1 ? head2 : head1;
+		ListNode curL = l;
+		ListNode curS = s;
+		ListNode last = curL;
+		int carry = 0;
+		int curNum = 0;
+		while (curS != null) {
+			curNum = curL.val + curS.val + carry;
+			curL.val = (curNum % 10);
+			carry = curNum / 10;
+			last = curL;
+			curL = curL.next;
+			curS = curS.next;
+		}
+		while (curL != null) {
+			curNum = curL.val + carry;
+			curL.val = (curNum % 10);
+			carry = curNum / 10;
+			last = curL;
+			curL = curL.next;
+		}
+		if (carry != 0) {
+			last.next = new ListNode(1);
+		}
+		return l;
+	}
+
+	public static int listLength(ListNode head) {
+		int len = 0;
+		while (head != null) {
+			len++;
+			head = head.next;
+		}
+		return len;
+	}
+
+}

src/class04/Code06_MergeTwoSortedLinkedList.java

@@ -0,0 +1,34 @@
+package class04;
+
+// 测试链接：https://leetcode.com/problems/merge-two-sorted-lists
+public class Code06_MergeTwoSortedLinkedList {
+
+	// 不要提交这个类
+	public static class ListNode {
+		public int val;
+		public ListNode next;
+	}
+
+	public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+		if (l1 == null || l2 == null) {
+			return l1 == null ? l2 : l1;
+		}
+		ListNode head = l1.val <= l2.val ? l1 : l2;
+		ListNode cur1 = head.next;
+		ListNode cur2 = head == l1 ? l2 : l1;
+		ListNode pre = head;
+		while (cur1 != null && cur2 != null) {
+			if (cur1.val <= cur2.val) {
+				pre.next = cur1;
+				cur1 = cur1.next;
+			} else {
+				pre.next = cur2;
+				cur2 = cur2.next;
+			}
+			pre = pre.next;
+		}
+		pre.next = cur1 != null ? cur1 : cur2;
+		return head;
+	}
+
+}