modify on class

Author: algorithmzuo

src/topinterviewquestions/Problem_0102_BinaryTreeLevelOrderTraversal.java

@@ -3,7 +3,6 @@
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Queue;
 
 public class Problem_0102_BinaryTreeLevelOrderTraversal {
 
@@ -18,28 +17,24 @@ public static List<List<Integer>> levelOrder(TreeNode root) {
 		if (root == null) {
 			return ans;
 		}
-		ans.add(new ArrayList<Integer>());
-		Queue<TreeNode> queue = new LinkedList<>();
-		queue.add(root);
-		TreeNode curEnd = root; // 当前层，最右节点是谁
-		TreeNode nextEnd = null; // 下一层，最右节点是谁
-		while (!queue.isEmpty()) {
-			TreeNode cur = queue.poll();
-			ans.get(ans.size() - 1).add(cur.val);
-			if (cur.left != null) {
-				queue.add(cur.left);
-				nextEnd = cur.left;
-			}
-			if (cur.right != null) {
-				queue.add(cur.right);
-				nextEnd = cur.right;
-			}
-			if (cur == curEnd) {
-				curEnd = nextEnd;
-				ans.add(new ArrayList<Integer>());
+		LinkedList<TreeNode> deque = new LinkedList<>();
+		deque.add(root);
+		int size = 0;
+		while(!deque.isEmpty()) {
+			size = deque.size();
+			List<Integer> curLevel = new ArrayList<>();
+			for(int i = 0 ; i< size;i++) {
+				TreeNode cur = deque.pollLast();
+				curLevel.add(cur.val);
+				if(cur.left != null) {
+					deque.addFirst(cur.left);
+				}
+				if(cur.right != null) {
+					deque.addFirst(cur.right);
+				}
 			}
+			ans.add(curLevel);
 		}
-		ans.remove(ans.size() - 1);
 		return ans;
 	}
 

src/topinterviewquestions/Problem_0103_BinaryTreeZigzagLevelOrderTraversal.java

@@ -1,8 +1,8 @@
 package topinterviewquestions;
 
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
-import java.util.Stack;
 
 public class Problem_0103_BinaryTreeZigzagLevelOrderTraversal {
 
@@ -17,35 +17,35 @@ public static List<List<Integer>> zigzagLevelOrder(TreeNode root) {
 		if (root == null) {
 			return ans;
 		}
-		ans.add(new ArrayList<>());
-		Stack<TreeNode> LR = new Stack<>();
-		Stack<TreeNode> RL = new Stack<>();
-		LR.add(root);
-		boolean era = true;
-		while (!LR.isEmpty() || !RL.isEmpty()) {
-			TreeNode cur = era ? LR.pop() : RL.pop();
-			ans.get(ans.size() - 1).add(cur.val);
-			if (era) {
-				if (cur.left != null) {
-					RL.push(cur.left);
+		LinkedList<TreeNode> deque = new LinkedList<>();
+		deque.add(root);
+		int size = 0;
+		boolean isHead = true;
+		while (!deque.isEmpty()) {
+			size = deque.size();
+			List<Integer> curLevel = new ArrayList<>();
+			for (int i = 0; i < size; i++) {
+				TreeNode cur = isHead ? deque.pollFirst() : deque.pollLast();
+				curLevel.add(cur.val);
+				if(isHead) {
+					if (cur.left != null) {
+						deque.addLast(cur.left);
+					}
+					if (cur.right != null) {
+						deque.addLast(cur.right);
+					}
+				}else {
+					if (cur.right != null) {
+						deque.addFirst(cur.right);
+					}
+					if (cur.left != null) {
+						deque.addFirst(cur.left);
+					}
 				}
-				if (cur.right != null) {
-					RL.push(cur.right);
-				}
-			} else {
-				if (cur.right != null) {
-					LR.push(cur.right);
-				}
-				if (cur.left != null) {
-					LR.push(cur.left);
-				}
-			}
-			if (((era && LR.isEmpty()) || (!era && RL.isEmpty()))) {
-				era = !era;
-				ans.add(new ArrayList<>());
 			}
+			ans.add(curLevel);
+			isHead = !isHead;
 		}
-		ans.remove(ans.size() - 1);
 		return ans;
 	}
 

src/topinterviewquestions/Problem_0104_MaximumDepthOfBinaryTree.java

@@ -15,9 +15,6 @@ public static int maxDepth(TreeNode root) {
 		if (root == null) {
 			return 0;
 		}
-		if (root.left == null && root.right == null) {
-			return 1;
-		}
         return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
 	}
 

src/topinterviewquestions/Problem_0105_ConstructBinaryTreeFromPreorderAndInorderTraversal.java

@@ -15,25 +15,24 @@ public static class TreeNode {
 	}
 
 	public static TreeNode buildTree(int[] preorder, int[] inorder) {
-		HashMap<Integer, Integer> inMap = new HashMap<>();
+		HashMap<Integer, Integer> map = new HashMap<>();
 		for (int i = 0; i < inorder.length; i++) {
-			inMap.put(inorder[i], i);
+			map.put(inorder[i], i);
 		}
-		return process(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, inMap);
+		return f(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, map);
 	}
 
-	public static TreeNode process(int[] pre, int L1, int R1, int[] in, int L2, int R2,
-			HashMap<Integer, Integer> inMap) {
+	public static TreeNode f(int[] pre, int L1, int R1, int[] in, int L2, int R2, HashMap<Integer, Integer> map) {
 		if (L1 > R1) {
 			return null;
 		}
 		TreeNode head = new TreeNode(pre[L1]);
 		if (L1 == R1) {
 			return head;
 		}
-		int find = inMap.get(pre[L1]);
-		head.left = process(pre, L1 + 1, L1 + find - L2, in, L2, find - 1, inMap);
-		head.right = process(pre, L1 + find - L2 + 1, R1, in, find + 1, R2, inMap);
+		int findIndex = map.get(pre[L1]);
+		head.left = f(pre, L1 + 1, L1 + findIndex - L2, in, L2, findIndex - 1, map);
+		head.right = f(pre, L1 + findIndex - L2 + 1, R1, in, findIndex + 1, R2, map);
 		return head;
 	}
 

src/topinterviewquestions/Problem_0116_PopulatingNextRightPointersInEachNode.java

@@ -12,17 +12,20 @@ public static class Node {
 	public static class MyQueue {
 		public Node head;
 		public Node tail;
+		public int size;
 
 		public MyQueue() {
 			head = null;
 			tail = null;
+			size = 0;
 		}
 
 		public boolean isEmpty() {
-			return head == null;
+			return size == 0;
 		}
 
 		public void offer(Node cur) {
+			size++;
 			if (head == null) {
 				head = cur;
 				tail = cur;
@@ -33,6 +36,7 @@ public void offer(Node cur) {
 		}
 
 		public Node poll() {
+			size--;
 			Node ans = head;
 			head = head.next;
 			ans.next = null;
@@ -45,28 +49,24 @@ public static Node connect(Node root) {
 		if (root == null) {
 			return root;
 		}
-		Node curLevelEnd = root;
-		Node nextLevelEnd = null;
-		Node pre = null;
 		MyQueue queue = new MyQueue();
 		queue.offer(root);
 		while (!queue.isEmpty()) {
-			Node cur = queue.poll();
-			if (pre != null) {
-				pre.next = cur;
-			}
-			pre = cur;
-			if (cur.left != null) {
-				queue.offer(cur.left);
-				nextLevelEnd = cur.left;
-			}
-			if (cur.right != null) {
-				queue.offer(cur.right);
-				nextLevelEnd = cur.right;
-			}
-			if (cur == curLevelEnd) {
-				curLevelEnd = nextLevelEnd;
-				pre = null;
+			// 第一个弹出的节点
+			Node pre = null;
+			int size = queue.size;
+			for (int i = 0; i < size; i++) {
+				Node cur = queue.poll();
+				if (cur.left != null) {
+					queue.offer(cur.left);
+				}
+				if (cur.right != null) {
+					queue.offer(cur.right);
+				}
+				if (pre != null) {
+					pre.next = cur;
+				}
+				pre = cur;
 			}
 		}
 		return root;

src/topinterviewquestions/Problem_0123_BestTimeToBuyAndSellStockIII.java

@@ -3,42 +3,20 @@
 public class Problem_0123_BestTimeToBuyAndSellStockIII {
 
 	public static int maxProfit(int[] prices) {
-		if (prices == null || prices.length == 0) {
+		if (prices == null || prices.length < 2) {
 			return 0;
 		}
-		return maxProfit(2, prices);
-	}
-
-	// 拓展股票问题
-	public static int maxProfit(int K, int[] prices) {
-		if (prices == null || prices.length == 0) {
-			return 0;
-		}
-		int N = prices.length;
-		if (K >= N / 2) {
-			return allTrans(prices);
-		}
-		// dp一维表
-		int[] dp = new int[N];
-		int ans = 0;
-		for (int tran = 1; tran <= K; tran++) {
-			int pre = dp[0];
-			int best = pre - prices[0];
-			for (int index = 1; index < N; index++) {
-				pre = dp[index];
-				dp[index] = Math.max(dp[index - 1], prices[index] + best);
-				best = Math.max(best, pre - prices[index]);
-				ans = Math.max(dp[index], ans);
-			}
-		}
-		return ans;
-	}
-
-	public static int allTrans(int[] prices) {
 		int ans = 0;
+		int doneOnceMinusBuyMax = -prices[0];
+		int doneOnceMax = 0;
+		int min = prices[0];
 		for (int i = 1; i < prices.length; i++) {
-			ans += Math.max(prices[i] - prices[i - 1], 0);
+			min = Math.min(min, prices[i]);
+			ans = Math.max(ans, doneOnceMinusBuyMax + prices[i]);
+			doneOnceMax = Math.max(doneOnceMax, prices[i] - min);
+			doneOnceMinusBuyMax = Math.max(doneOnceMinusBuyMax, doneOnceMax - prices[i]);
 		}
 		return ans;
 	}
+
 }

src/topinterviewquestions/Problem_0188_BestTimeToBuyAndSellStockIV.java

@@ -0,0 +1,36 @@
+package topinterviewquestions;
+
+public class Problem_0188_BestTimeToBuyAndSellStockIV {
+
+	public static int maxProfit(int K, int[] prices) {
+		if (prices == null || prices.length == 0) {
+			return 0;
+		}
+		int N = prices.length;
+		if (K >= N / 2) {
+			return allTrans(prices);
+		}
+		int[][] dp = new int[K + 1][N];
+		int ans = 0;
+		for (int tran = 1; tran <= K; tran++) {
+			int pre = dp[tran][0];
+			int best = pre - prices[0];
+			for (int index = 1; index < N; index++) {
+				pre = dp[tran - 1][index];
+				dp[tran][index] = Math.max(dp[tran][index - 1], prices[index] + best);
+				best = Math.max(best, pre - prices[index]);
+				ans = Math.max(dp[tran][index], ans);
+			}
+		}
+		return ans;
+	}
+
+	public static int allTrans(int[] prices) {
+		int ans = 0;
+		for (int i = 1; i < prices.length; i++) {
+			ans += Math.max(prices[i] - prices[i - 1], 0);
+		}
+		return ans;
+	}
+
+}