这篇文章记录一下本人刷题的思路和解法，刷题的顺序是按照覃超老师的《算法面试通关40讲》课程，边学习边记录，还没有学完，持续更新。
链表部分
206. Reverse Linked List
反转链表
循环
三个指针，注意处理head为空的情况
class Solution {
public ListNode reverseList(ListNode head) {
ListNode prev = null, curr = head, next;
while(curr != null) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
}
}
递归
翻转next之后的链表，再翻转头结点，注意保存并返回新的头结点
class Solution {
public ListNode reverseList(ListNode head) {
if(head == null || head.next == null) {
return head;
}
ListNode newHead = reverseList(head.next);
head.next.next = head;
head.next = null;
return newHead;
}
}
24. Swap Nodes in Pairs
成对反转
循环
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode p1 = dummy, p2;
while(p1.next != null && p1.next.next != null) {
p2 = p1.next.next;
p1.next.next = p2.next;
p2.next = p1.next;
p1.next = p2;
p1 = p2.next;
}
return dummy.next;
}
}
递归
class Solution {
public ListNode swapPairs(ListNode head) {
if(head == null || head.next == null) {
return head;
}
ListNode n = head.next;
head.next = swapPairs(n.next);
n.next = head;
return n;
}
}
141. Linked List Cycle
判断链表有环 快慢指针
public class Solution {
public boolean hasCycle(ListNode head) {
ListNode walker = head, runner = head;
while(runner != null && runner.next != null) {
walker = walker.next;
runner = runner.next.next;
if(walker == runner) {
return true;
}
}
return false;
}
}
142. Linked List Cycle II
找到环中第一个节点
a + b + mr
fast 走了
a + b + nr
fast 的速度是 slow 的两倍，所以有
2(a + b + mr) = a + b + nr
a + b = (n - 2m)r = or
又因为
b + c = r
所以有
a = c + pr
上面 m、n、o、p 都是未知整数，不影响结果。所以一个指针从 p 点出发，一个指针从head出发，每次前进一步，肯定会在 q 点相遇。
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast = head, slow = head;
while(fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if(fast == slow) {
slow = head;
while(slow != fast) {
fast = fast.next;
slow = slow.next;
}
return slow;
}
}
return null;
}
}
25. Reverse Nodes in k-Group
每K个元素一组，反转链表
循环
- 实现辅助方法 reverse，用于反转 head 到 tail；
- 定义dummy和tail，用于记录当前已经反转完成的部分；
- 每次数k个节点出来，反转完成后加到结尾；
- 如果节点不足k个，就把剩下的加到结尾然后返回。
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
ListNode dummy = new ListNode(0), tail = dummy;
ListNode currHead = head, curr = head, nextHead;
while(true) {
for(int i = 0; i < k; i++) {
if(curr == null) {
tail.next = currHead;
return dummy.next;
}
curr = curr.next;
}
nextHead = curr;
tail.next = reverse(currHead, nextHead);
tail = currHead;
currHead = nextHead;
}
}
private ListNode reverse(ListNode head, ListNode tail) {
ListNode prev = null, curr = head, next;
while(curr != null && curr != tail) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
}
}
递归
- 数出k个节点，如果不够就返回head；
- 递归反转后面的部分；
- 反转k个节点，尾部加上后面反转完成的节点。
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
ListNode p = head;
for(int i = 0; i < k; i++) {
if(p == null) {
return head;
}
p = p.next;
}
ListNode prev = reverseKGroup(p, k), curr = head, next;
for(int i = 0; i< k; i++) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
}
}
栈和队列
队列和栈应该使用 LinkedList 或者 ArrayDeque，队列对应的方法应该使用 offer / poll / peek，这三个方法不会抛出异常；双端队列使用 的方法为 offerFirst / offerLast / pollFirst / pollLast / peekFirst / peekLast 栈对应的方法应该使用 push / pop / peek。
20. Valid Parentheses
括号匹配问题，注意空的 stack 调用 pop 方法会抛出异常，Stack 和 Deque 都是这样，所以要做判断。
class Solution {
public boolean isValid(String s) {
LinkedList<Character> stack = new LinkedList<>();
for(char c : s.toCharArray()) {
if(c == '('){
stack.push(')');
} else if(c == '[') {
stack.push(']');
} else if(c == '{') {
stack.push('}');
} else if(stack.isEmpty() || stack.pop() != c) {
return false;
}
}
return stack.isEmpty();
}
}
232. Implement Queue using Stacks
用栈实现队列，没什么难度，满了再倒过来
class MyQueue {
private final Deque<Integer> s1;
private final Deque<Integer> s2;
/** Initialize your data structure here. */
public MyQueue() {
s1 = new LinkedList<>();
s2 = new LinkedList<>();
}
/** Push element x to the back of queue. */
public void push(int x) {
s2.push(x);
}
/** Removes the element from in front of queue and returns that element. */
public int pop() {
peek();
return s1.pop();
}
/** Get the front element. */
public int peek() {
if(s1.isEmpty()) {
while(!s2.isEmpty()) {
s1.push(s2.pop());
}
}
return s1.peek();
}
/** Returns whether the queue is empty. */
public boolean empty() {
return s1.isEmpty() && s2.isEmpty();
}
}
225. Implement Stack using Queues
用队列实现栈，在push的时候反转一遍，这样pop和peek就不会出问题了
class MyStack {
private final Queue<Integer> q;
/** Initialize your data structure here. */
public MyStack() {
q = new LinkedList<>();
}
/** Push element x onto stack. */
public void push(int x) {
q.offer(x);
for(int i = 0; i < q.size() - 1; i++) {
q.offer(q.poll());
}
}
/** Removes the element on top of the stack and returns that element. */
public int pop() {
return q.poll();
}
/** Get the top element. */
public int top() {
return q.peek();
}
/** Returns whether the stack is empty. */
public boolean empty() {
return q.isEmpty();
}
}
703. Kth Largest Element in a Stream
最大K个值，使用优先级队列。注意默认排序方式是升序，即最小堆。
class KthLargest {
private final Queue<Integer> q;
private final int k;
public KthLargest(int k, int[] nums) {
this.q = new PriorityQueue<>(k);
this.k = k;
for(int i : nums) {
add(i);
}
}
public int add(int val) {
if(q.size() < k) {
q.offer(val);
} else if(val > q.peek()) {
q.poll();
q.offer(val);
}
return q.peek();
}
}
优先级队列
239. Sliding Window Maximum
滑动窗口求最大值
使用最大堆
有两点需要注意：
- Queue 继承了 Collection 接口，也有 remove 指定元素的方法；
- 默认是最小堆，要传入最大堆，注意反转 Comparator 的写法；
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if(nums.length == 0) {
return nums;
}
Queue<Integer> q = new PriorityQueue<>(new Comparator<Integer>() {
public int compare(Integer i1, Integer i2) {
return Integer.compare(i2, i1);
}
});
for(int i = 0; i < k - 1; i++) {
q.offer(nums[i]);
}
int[] res = new int[nums.length - k + 1];
for(int i = k - 1; i < nums.length; i++) {
q.offer(nums[i]);
res[i - k + 1] = q.peek();
q.remove(nums[i - k + 1]);
}
return res;
}
}
双端队列
看起来比较优雅，但是时间复杂度其实是 O(kn)，最坏情况下每个元素都需要和 k 个元素做比较。
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if(nums.length == 0) {
return new int[0];
}
Deque<Integer> q = new ArrayDeque<>(k);
int[] res = new int[nums.length - k + 1];
for(int i = 0; i < nums.length; i++) {
if(!q.isEmpty() && i >= k && nums[i - k] == q.peekFirst()) {
q.pollFirst();
}
while(!q.isEmpty() && q.peekLast() < nums[i]) {
q.pollLast();
}
q.offer(nums[i]);
if(i >= k - 1) {
res[i - k + 1] = q.peekFirst();
}
}
return res;
}
}
哈希表
242. Valid Anagram
判断是不是同构字符串，即每个字母使用的数量都一样，三种解法，排序、哈希表以及数组代替哈希表。
使用 HashMap
class Solution {
public boolean isAnagram(String s, String t) {
if(s.length() != t.length()) {
return false;
}
Map<Character,Integer> map = new HashMap();
for(char c : s.toCharArray()) {
if(!map.containsKey(c)) {
map.put(c, 1);
} else {
map.put(c, map.get(c) + 1);
}
}
for(char c : t.toCharArray()) {
Integer count = map.get(c);
if(count == null || count == 0){
return false;
} else {
map.put(c, count - 1);
}
}
return true;
}
}
使用数组
题目中有说明，所有的字符都是小写字母，因此可以使用一个长度为26的数组记录每个字符出现的次数，每个字符和字符'a'相减得到其index。
class Solution {
public boolean isAnagram(String s, String t) {
if(s.length() != t.length()) {
return false;
}
int[] table = new int[26];
for(char c : s.toCharArray()) {
table[c - 'a']++;
}
for(char c : t.toCharArray()) {
table[c - 'a']--;
}
for(int i : table) {
if(i != 0) {
return false;
}
}
return true;
}
}
1. Two Sum
三种解法：
- 暴力循环，两层嵌套；
- HashMap 遍历两遍，第一遍把所有元素和对应的index放进去，第二遍根据当前元素nums[i]查找target-nums[i]，找到就返回下标；
- HashMap 遍历一遍，根据当前元素nums[i]查找target-nums[i]，找到就返回下标，找不到把nums[i]和i放进去。
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++) {
if(map.containsKey(target - nums[i])) {
return new int[]{map.get(target - nums[i]), i};
}
map.put(nums[i],i);
}
return null;
}
}
15. 3Sum
给定一个数组，找到其中所有和为0的三个元素的组合，不能有重复组合。
使用Set
内层类似 two sum 的解法，复杂度是O(N2)，注意需要先排序，否则解决不了重复值的问题
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
Set<List<Integer>> set = new HashSet<>();
for(int i = 0; i < nums.length; i++) {
Set<Integer> s = new HashSet<>();
for(int j = i + 1; j < nums.length; j++) {
int search = - nums[i] - nums[j];
if(s.contains(search)) {
set.add(Arrays.asList(nums[i], nums[j], search));
} else {
s.add(nums[j]);
}
}
}
return new ArrayList(set);
}
}
双指针1
外层依次遍历，内层双指针，难点是重复值问题，注意如果 nums[i] == nums[i + 1]，应该跳过的是 i + 1，不能跳过 i，否则会漏掉结果。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> list = new ArrayList<>();
for(int i = 0; i< nums.length - 2 && nums[i] <= 0; i++) {
if(i > 0 && nums[i] == nums[i - 1])
continue;
int j = i + 1, k = nums.length - 1;
while(j < k) {
int sum = nums[i] + nums[j] + nums[k];
if(sum > 0) {
k--;
} else if(sum < 0) {
j++;
} else {
list.add(Arrays.asList(nums[i], nums[j], nums[k]));
while(j < k && nums[j + 1] == nums[i])
j++;
while(j < k && nums[k - 1] == nums[k])
k--;
j++;
k--;
}
}
}
return list;
}
}
双指针2
和上面类似，使用 set 来避免重复值问题。由于已经排序，所以 nums[i] <= nums[j] <= nums[k]，因此 set 中的每个 list 都是有序的，因此重复值可以排除掉。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
Set<List<Integer>> set = new HashSet<>();
final int n = nums.length;
for(int i = 0; i< n; i++) {
int j = i + 1, k = n - 1;
while(k > j) {
int sum = nums[i] + nums[j] + nums[k];
if(sum > 0) {
k--;
} else if(sum < 0) {
j++;
} else {
set.add(Arrays.asList(nums[i], nums[j], nums[k]));
j++;
k--;
}
}
}
return new ArrayList(set);
}
}
二叉树
98. Validate Binary Search Tree
验证二叉搜索树。注意二叉搜索树的定义，是左子树中所有的元素都小于当前元素，右子树中所有的元素都大于当前元素，并不是每个节点 left < val < right 就可以了，例如 [4,3,7,1,5,6,8] 这棵树，每个节点都满足 left < val < right，但却不是二次搜索树。
问题的难点在于，每个节点验证子树是否合法时，要和左子树的最大节点比较，又要和右子树的最小节点比较，同时需要向上级返回当前子树的最小值和最大值，所以一个返回值是做不到的。解决方法有两个，一种是返回一个int数组，分别放入最小值和最大值，即解法一；另一种是自上而下，通过传入最大最小值完成判断，不必将这两个值传回，即解法二。
还有另外一种思路，搜索二叉树中序遍历的结果是有序的，所以直接中序遍历就可以了，即解法三。
递归解法一
checkNode 方法返回 null 表示子树不合法，否则是个长度为2的数组，第一位是子树中的最小值，第二位是子树中的最大值。
class Solution {
public boolean isValidBST(TreeNode root) {
return root == null || checkNode(root) != null;
}
private int[] checkNode(TreeNode root) {
int[] left = null, right = null;
if(root.left != null) {
left = checkNode(root.left);
if(left == null || left[1] >= root.val) {
return null;
}
}
if(root.right != null) {
right = checkNode(root.right);
if(right == null || right[0] <= root.val) {
return null;
}
}
return new int[] {
left != null ? left[0]: root.val,
right != null ? right[1]: root.val
};
}
}
递归解法二
自上而下，传入最大值和最小值限定。注意这里 min 和 max 要使用Integer，传入 null 表示没有限制。如果使用 int 并且传入 Integer.MIN_VALUE 和 Integer.MAX_VALUE 的话，树中将不能保存 Integer.MIN_VALUE 和 Integer.MAX_VALUE，导致有的 TestCase 无法通过。
class Solution {
public boolean isValidBST(TreeNode root) {
return isValidBST(root, null, null);
}
private boolean isValidBST(TreeNode root, Integer min, Integer max) {
if(root == null) return true;
if(min != null && root.val <= min || max != null && root.val >= max) return false;
return isValidBST(root.left, min, root.val) && isValidBST(root.right, root.val, max);
}
}
中序遍历法
递归遍历，需要使用成员变量保存前一个值，不需要用队列保存所有值。
class Solution {
private Integer prev;
public boolean isValidBST(TreeNode root) {
if(root == null)
return true;
if(!isValidBST(root.left))
return false;
if(prev != null && prev >= root.val) {
return false;
} else {
prev = root.val;
}
return isValidBST(root.right);
}
}
236. Lowest Common Ancestor of a Binary Tree
最小公共祖先。
递归
很牛逼的一种解法，公共节点有两种情况，一种情况 p 或者 q 为另一个的祖先节点，另一种情况就是 p 和 q 分别分布在祖先节点的两侧。
对于每个节点，有以下几种情况：
- 左侧右侧都没有 p 或者 q，那么这个节点没用，返回 null；
- 某一侧有 p 或者 q，返回这一侧；
- 两侧都有，这个节点就是最小公共节点，返回它，它的所有节点都会符合上一点，最终会返回当前节点。
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(root == null || root == p || root == q) return root;
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if(left == null)
return right;
else if(right == null)
return left;
else
return root;
}
}
查找公共路径
从 root 开始分别查找 p 和 q，记录下来路径，找到路径中最后一个重合的节点即可。
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
Deque<TreeNode> sp = new LinkedList<>();
Deque<TreeNode> sq = new LinkedList<>();
if(!search(root, p, sp) || !search(root, q, sq)) {
return null;
}
TreeNode res = null;
while(sp.peekFirst() == sq.peekFirst()) {
res = sp.pollFirst();
sq.pollFirst();
}
return res;
}
private boolean search(TreeNode root, TreeNode target, Deque<TreeNode> q) {
if(root == null)
return false;
q.offerLast(root);
if(root == target || search(root.left, target, q) || search(root.right, target, q))
return true;
q.pollLast();
return false;
}
}
235. Lowest Common Ancestor of a Binary Search Tree
二叉搜索树的最小公共祖先，比较简单，根据二叉搜索树的特点，可以直接根据值来判断。
递归
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(root == null) return root;
if(p.val < root.val && q.val < root.val) {
return lowestCommonAncestor(root.left, p, q);
} else if(p.val > root.val && q.val > root.val) {
return lowestCommonAncestor(root.right, p, q);
} else {
return root;
}
}
}
循环
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
while(true) {
if(p.val < root.val && q.val < root.val) {
root = root.left;
} else if(p.val > root.val && q.val > root.val) {
root = root.right;
} else {
return root;
}
}
}
}
144. Binary Tree Preorder Traversal
先序遍历二叉树
递归
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
preorderTraversal(root,list);
return list;
}
private void preorderTraversal(TreeNode root, List<Integer> list) {
if(root == null) return;
list.add(root.val);
preorderTraversal(root.left, list);
preorderTraversal(root.right, list);
}
}
循环
使用一个栈，右侧先入栈
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
if(root == null)
return Collections.emptyList();
List<Integer> list = new ArrayList<>();
Deque<TreeNode> stack = new LinkedList<>();
stack.push(root);
TreeNode curr;
while(!stack.isEmpty()) {
curr = stack.pop();
list.add(curr.val);
if(curr.right != null) {
stack.push(curr.right);
}
if(curr.left != null) {
stack.push(curr.left);
}
}
return list;
}
}
94. Binary Tree Inorder Traversal
中序遍历二叉树
递归
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
inorderTraversal(root, list);
return list;
}
private void inorderTraversal(TreeNode root, List<Integer> list) {
if(root == null) return;
inorderTraversal(root.left, list);
list.add(root.val);
inorderTraversal(root.right, list);
}
}
循环
遍历的步骤如下：
- root 入栈，并另 root = root.left，直到 root 为 null；
- 出栈并赋值给 root，添加 root 的值，并另 root = root.right，回到步骤1；
- 直到 root 为空，且栈为空。
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
if(root == null)
return Collections.emptyList();
List<Integer> list = new ArrayList<>();
Deque<TreeNode> stack = new LinkedList<>();
while(!stack.isEmpty() || root != null) {
if(root != null) {
stack.push(root);
root = root.left;
} else {
root = stack.pop();
list.add(root.val);
root = root.right;
}
}
return list;
}
}
145. Binary Tree Postorder Traversal
后序遍历二叉树
递归
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
postorderTraversal(root, list);
return list;
}
private void postorderTraversal(TreeNode root, List<Integer> list) {
if(root == null) return;
postorderTraversal(root.left, list);
postorderTraversal(root.right, list);
list.add(root.val);
}
}
循环
使用一个栈，每个元素都入栈出栈一次，出栈的时候加入列表中并子节点入栈。注意这样对应的其实是【根右左】的顺序，结果是反的，所以加入到列表的时候要加到表头，相当于完成了一次反转。
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
if(root == null)
return Collections.emptyList();
LinkedList<Integer> list = new LinkedList<>();
Deque<TreeNode> stack = new LinkedList<>();
stack.push(root);
while(!stack.isEmpty()) {
root = stack.pop();
list.push(root.val);
if(root.left != null) {
stack.push(root.left);
}
if(root.right != null) {
stack.push(root.right);
}
}
return list;
}
}
102. Binary Tree Level Order Traversal
层序遍历，并且每一行输出一个list
循环
使用双端队列保存每个节点的子节点，指针 last 记住每一行的最后一个节点，当到达每一行的末尾时，将 last 赋值为队列末尾的节点即可。
也可以使用一个普通队列，但是要加一个指针，一直记录队尾的节点。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null)
return Collections.emptyList();
List<List<Integer>> list = new ArrayList<>();
Deque<TreeNode> q = new LinkedList<>();
TreeNode curr, last = root;
q.offer(root);
List<Integer> level = new ArrayList<>();
while(!q.isEmpty()) {
curr = q.poll();
level.add(curr.val);
if(curr.left != null) {
q.offer(curr.left);
}
if(curr.right != null) {
q.offer(curr.right);
}
if(curr == last) {
list.add(level);
level = new ArrayList<>();
last = q.peekLast();
}
}
return list;
}
}
递归解法
将要返回的大 list 传给递归函数，以及要处理的节点，节点所在层级，这样就能把每个节点加到对应行中。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list = new ArrayList<>();
levelOrder(list, root, 0);
return list;
}
private void levelOrder(List<List<Integer>> list, TreeNode root, int level) {
if(root == null) {
return;
}
List<Integer> l;
if(list.size() == level) {
l = new ArrayList<>();
list.add(l);
} else {
l = list.get(level);
}
l.add(root.val);
levelOrder(list, root.left, level + 1);
levelOrder(list, root.right, level + 1);
}
}
103. Binary Tree Zigzag Level Order Traversal
循环解法
使用双端队列，从左往右时加到队尾，从右往左是加到队头，用指针 last 记录每一行的最后一个节点。注意如果是要求直接打印的话，只有这种方法可以搞定。
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
if(root == null)
return Collections.emptyList();
boolean lr = true;
Deque<TreeNode> dq = new ArrayDeque<>();
List<List<Integer>> list = new ArrayList<>();
List<Integer> ll = new ArrayList<>();
TreeNode curr, last = root;
dq.push(root);
while(!dq.isEmpty()) {
curr = lr ? dq.pollFirst() : dq.pollLast();
ll.add(curr.val);
if(lr) {
if(curr.left != null) {
dq.offerLast(curr.left);
}
if(curr.right != null) {
dq.offerLast(curr.right);
}
} else {
if(curr.right != null) {
dq.offerFirst(curr.right);
}
if(curr.left != null) {
dq.offerFirst(curr.left);
}
}
if(curr == last) {
last = lr ? dq.peekFirst() : dq.peekLast();
lr = !lr;
list.add(ll);
ll = new ArrayList<>();
}
}
return list;
}
}
循环解法二
这种更简单一些，和普通层序遍历差不多，只不过从右往左时元素是加到列表头部的，相当于做了反转。
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
if(root == null)
return Collections.emptyList();
boolean lr = true;
Deque<TreeNode> dq = new ArrayDeque<>();
List<List<Integer>> list = new ArrayList<>();
List<Integer> ll = new ArrayList<>();
TreeNode curr, last = root;
dq.push(root);
while(!dq.isEmpty()) {
curr = dq.pollFirst();
if(lr) {
ll.add(curr.val);
} else {
ll.add(0, curr.val);
}
if(curr.left != null) {
dq.offerLast(curr.left);
}
if(curr.right != null) {
dq.offerLast(curr.right);
}
if(curr == last) {
last = dq.peekLast();
lr = !lr;
list.add(ll);
ll = new ArrayList<>();
}
}
return list;
}
}
递归解法
和上面的题类似，不过要根据当前行数奇偶，判断从前端还是后端插入。
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> list = new ArrayList<>();
zigzagLevelOrder(list, root, 0);
return list;
}
private void zigzagLevelOrder(List<List<Integer>> list, TreeNode root, int level) {
if(root == null) {
return;
}
List<Integer> l;
if(list.size() == level) {
l = new ArrayList<>();
list.add(l);
} else {
l = list.get(level);
}
if(level % 2 == 0) {
l.add(root.val);
} else {
l.add(0, root.val);
}
zigzagLevelOrder(list, root.left, level + 1);
zigzagLevelOrder(list, root.right, level + 1);
}
}
分治
50. Pow(x, n)
求 x 的 n 次方，注意 n 可能是负数，也可能是 Integer.MIN_VALUE，Integer.MIN_VALUE 取负还是它本身，这是个坑。
注意一点，余数的绝对值等于被除数绝对值和除数绝对值取余的结果，符号和被除数一致。
分治法一
这种解法用了分治思想，每次减少一半，除不尽的再乘以一次 x。有一点就是 n 为负数的情况，其实不需要做特殊处理，只是真正相乘的时候判断一下，乘上它的倒数就可以了，这样也不需要处理 Integer.MIN_VALUE 了。
class Solution {
public double myPow(double x, int n) {
if(n == 0) return 1;
double half = myPow(x, n / 2);
double remainder = n % 2 == 0 ? 1 : n > 0 ? x : 1 / x;
return half * half * remainder;
}
}
分治法二
和上面类似，核心问题是将 pow(x, n) 转化为 pow(x * x, n / 2)，同时不要忘记处理 n 为负数的情况。
class Solution {
public double myPow(double x, int n) {
if(n == 0) return 1;
return myPow(x * x, n / 2) * (n % 2 == 0 ? 1 : n > 0 ? x : 1 / x);
}
}
位移法
位移法比较巧妙，例如 x10 = x8 + 2，即把 n 拆解成 2 的幂和的形式，然后 x 每次自称，也就是 x 的1，2，4，16...次幂，如果 n 的当前位为1，就乘上去。这个解法没法处理负数，所以 Integer.MIN_VALUE 和负数需要转换一下。
class Solution {
public double myPow(double x, int n) {
if(n == Integer.MIN_VALUE)
return myPow(x * x, n / 2);
if(n < 0)
return myPow(1 / x, -n);
double r = 1;
while(n > 0) {
if((n & 1) != 0)
r *= x;
x *= x;
n >>= 1;
}
return r;
}
}
169. Majority Element
找到数组中数量超过总数一半的那个数。
Map 解法
使用 HashMap，时间复杂度 O(N)，空间复杂度 O(N)。
class Solution {
public int majorityElement(int[] nums) {
Map<Integer,Integer> map = new HashMap<>();
for(int i : nums) {
int count = map.containsKey(i) ? map.get(i) + 1 : 1;
if(count > nums.length / 2)
return i;
map.put(i, count);
}
return 0;
}
}
排序解法
时间复杂度 O(NlogN)。
class Solution {
public int majorityElement(int[] nums) {
Arrays.sort(nums);
return nums[nums.length / 2];
}
}
摩尔投票法
时间复杂度 O(N)。
class Solution {
public int majorityElement(int[] nums) {
int m = nums[0];
int count = 1;
for(int i = 1; i < nums.length; i++) {
if(nums[i] == m) {
count++;
} else if(count == 0) {
m = nums[i];
count = 1;
} else {
count--;
}
}
return m;
}
}
分治解法
分治也可以解决，时间复杂度是 O(NlogN)，注意两边 majority 不一致的时候要比较 lm 和 rm 哪个出现比较多，是在 lo 到 hi 中数的。
class Solution {
public int majorityElement(int[] nums) {
return majority(nums, 0, nums.length - 1);
}
private int majority(int[] nums, int lo, int hi) {
if(lo == hi)
return nums[lo];
int mid = (lo + hi) >>> 1;
int lm = majority(nums, lo, mid);
int rm = majority(nums, mid + 1, hi);
if(lm == rm)
return lm;
int lc = count(nums, lo, hi, lm);
int rc = count(nums, lo, hi, rm);
return lc >= rc ? lm : rm;
}
private int count(int[] nums, int lo, int hi, int target) {
int count = 0;
for(int i = lo; i <= hi; i++)
if(nums[i] == target)
count++;
return count;
}
}
贪心
122. Best Time to Buy and Sell Stock II
买卖股票最佳时机，允许多次买卖。
只要涨就买，跌就卖。
class Solution {
public int maxProfit(int[] prices) {
int p = 0;
for(int i = 0; i < prices.length - 1; i++)
if(prices[i + 1] > prices[i])
p += prices[i + 1] - prices[i];
return p;
}
}
BFS 和 DFS
104. Maximum Depth of Binary Tree
class Solution {
public int maxDepth(TreeNode root) {
return root == null ? 0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}
111. Minimum Depth of Binary Tree
class Solution {
public int minDepth(TreeNode root) {
if(root == null)
return 0;
if(root.left == null)
return minDepth(root.right) + 1;
if(root.right == null)
return minDepth(root.left) + 1;
return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
}
}
22. Generate Parentheses
生成所有匹配括号。
这个问题的重点在于，什么样的括号组合是合法的。和括号匹配那道题不同，这里只会出现一种括号，所以不需要用栈去验证，规则其实很简单，从左往右扫描，任何时刻左括号的数量多于右括号的数量，直到结束，这样的字符串就是合法的。
所以生成的方法就是递归，生成的过程中及时去掉不符合条件的分支，生成完成后加入列表中即可。
class Solution {
public List<String> generateParenthesis(int n) {
List<String> list = new ArrayList<>();
generate(n, n, "", list);
return list;
}
private void generate(int left, int right, String str, List<String> list) {
if (left == 0 && right == 0) {
list.add(str);
return;
}
if (left > 0)
generate(left - 1, right, str + '(', list);
if (right > left)
generate(left, right - 1, str + ')', list);
}
}
剪枝
51. N-Queens
N 皇后问题，需要注意下面几点：
- 使用三个 Set 分别记录已经被占用的列（col）、左斜（sum）和右斜（diff），这样的好处是简化计算并且便于回退。另一种方法是使用二位数组涂色，缺点是无法回退，所以每次都需要复制数组，麻烦且空间开销较大；
- 使用 int 数组 curr 记录每一行中 Q 所在的列，因为确定每行有且只有一个 Q，所以使用以为数组即可；
- 注意终止条件。
class Solution {
public List<List<String>> solveNQueens(int n) {
List<List<String>> list = new ArrayList<>();
Set<Integer> sum = new HashSet();
Set<Integer> diff = new HashSet();
Set<Integer> col = new HashSet();
int[] curr = new int[n];
solve(n, 0, sum, diff, col, list, curr);
return list;
}
private void solve(int n, int row, Set<Integer> sum, Set<Integer> diff, Set<Integer> col, List<List<String>> list, int[] curr) {
if(row == n) {
list.add(toList(curr));
return;
}
for (int i = 0; i < n; i++) {
if (col.contains(i) || sum.contains(row + i) || diff.contains(row - i))
continue;
col.add(i);
sum.add(row + i);
diff.add(row - i);
curr[row] = i;
solve(n, row + 1, sum, diff, col, list, curr);
col.remove(i);
sum.remove(row + i);
diff.remove(row - i);
}
}
private List<String> toList(int[] arr) {
List<String> list = new ArrayList<>();
for(int i = 0; i < arr.length; i++) {
StringBuilder row = new StringBuilder();
for(int j = 0; j < arr.length; j++) {
row.append(j == arr[i] ? 'Q' : '.');
}
list.add(row.toString());
}
return list;
}
}
52. N-Queens II
这题的区别是不需要输出答案，只需要计算结果数量
思路和上题相同，只是不再需要记录 Q 所在的位置，也不需要返回 Q 的具体摆放方式，只要返回数量即可。
class Solution {
public int totalNQueens(int n) {
Set<Integer> sum = new HashSet(), diff = new HashSet(), col = new HashSet();
return solve(n, 0, col, sum, diff);
}
private int solve(int n, int row, Set<Integer> col, Set<Integer> sum, Set<Integer> diff) {
if(row == n)
return 1;
int count = 0;
for (int i = 0; i < n; i++) {
if (col.contains(i) || sum.contains(row + i) || diff.contains(row - i))
continue;
col.add(i);
sum.add(row + i);
diff.add(row - i);
count += solve(n, row + 1, col, sum, diff);
col.remove(i);
sum.remove(row + i);
diff.remove(row - i);
}
return count;
}
}
37. Sudoku Solver
数独求解，注意数独的规则，每一行是1-9，每一列是1-9，并且整体被划分为 9 个 3 x 3 的区间，每个区间也要包含 1-9。
总体思路就是从头到尾遍历每个格子，如果是空的就根据规则填上数字，再继续下一个位置。搜索完每个值之后要还原空位，再尝试下一个值，直到成功。
注意位置计算的技巧，以及还原现场。
class Solution {
public void solveSudoku(char[][] board) {
solve(board, 0);
}
private boolean solve(char[][] board, int count) {
for(int i = count; i < 81; i++) {
int row = i / 9;
int col = i % 9;
if(board[row][col] == '.') {
for(char c = '1'; c <= '9'; c++) {
boolean repeated = false;
for(int k = 0; k < 9; k++) {
if(board[row][k] == c || board[k][col] == c
|| board[row / 3 * 3 + k / 3][col / 3 * 3 + k % 3] == c) {
repeated = true;
break;
}
}
if(!repeated) {
board[row][col] = c;
if(solve(board, i + 1))
return true;
board[row][col] = '.';
}
}
return false;
}
}
return true;
}
}
36. Valid Sudoku
判断数独是否合法，不需要解出来，只需要验证已经填上的数字是不是合法。
暴力求解
分别遍历行、列、块，使用一个 int 作为 Set，记录每个值是否出现过，这个解法看起来不优雅，但是效率是最高的，也没有空间开销。
class Solution {
public boolean isValidSudoku(char[][] board) {
int set, flag;
for (int i = 0; i < 9; i++) {
set = 0;
for (int j = 0; j < 9; j++) {
if (board[i][j] != '.') {
int k = board[i][j] - '1';
flag = 1 << k;
if ((set & flag) > 0)
return false;
set |= flag;
}
}
}
for (int i = 0; i < 9; i++) {
set = 0;
for (int j = 0; j < 9; j++) {
if (board[j][i] != '.') {
int k = board[j][i] - '1';
flag = 1 << k;
if ((set & flag) != 0)
return false;
set |= flag;
}
}
}
for (int i = 0; i < 9; i++) {
set = 0;
int row = i / 3 * 3;
int col = i % 3 * 3;
for (int j = 0; j < 9; j++) {
if (board[row + j / 3][col + j % 3] != '.') {
int k = board[row + j / 3][col + j % 3] - '1';
flag = 1 << k;
if ((set & flag) != 0)
return false;
set |= flag;
}
}
}
return true;
}
}
使用 Set
这个写法很讨巧，使用一个 Set，记录区分了行、列、块三种情况，并且记录了对应的 index 信息。注意 Set.add 方法返回值是 boolean 类型，如果元素已经存在，返回值是 false。
这种写法看起来会比较简短，但是效率并不高，还需要分配一个 Set。
class Solution {
public boolean isValidSudoku(char[][] board) {
Set<String> set = new HashSet<>();
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c != '.'
&& (!set.add("r" + i + c) || !set.add("c" + j + c)
|| !set.add("b" + i / 3 + j / 3 + c)))
return false;
}
}
return true;
}
}
二分查找
69. Sqrt(x)
开平方。
二分查找
难点在于处理好边界。
- 如果使用乘法，必定会出现溢出的情况，所以要使用除法；
- 0 和 1 要处理好；
- 由于结果要求整数，会存在取整的问题，要处理好。
class Solution {
public int mySqrt(int x) {
int lo = 1, hi = x, mid;
while(hi >= lo) {
mid = (hi + lo) >>> 1;
if(x / mid < mid)
hi = mid - 1;
else if(x / (mid + 1) > mid)
lo = mid + 1;
else
return mid;
}
return 0;
}
}
牛顿迭代法
牛顿迭代法公式：xn+1 = xn - f(xn) / f'(xn)
f(x) = x2 - a，f'(x) = 2x，所以有 xn+1 = 1 / 2 * ( xn + a / xn )
这里溢出问题不好处理，可以使用 long 防止溢出。
class Solution {
public int mySqrt(int x) {
long r = x;
while(r * r > x) {
r = (r + x / r) / 2;
}
return (int)r;
}
}
Trie 树
208. Implement Trie (Prefix Tree)
实现 Trie 树。
class Trie {
private final TrieNode root;
/** Initialize your data structure here. */
public Trie() {
root = new TrieNode();
}
/** Inserts a word into the trie. */
public void insert(String word) {
TrieNode curr = root;
for (char c : word.toCharArray()) {
int index = c - 'a';
if (curr.children[index] == null) {
curr.children[index] = new TrieNode();
}
curr = curr.children[index];
}
curr.isWord = true;
}
/** Returns if the word is in the trie. */
public boolean search(String word) {
TrieNode curr = root;
for (char c : word.toCharArray()) {
int index = c - 'a';
if (curr.children[index] == null) {
return false;
}
curr = curr.children[index];
}
return curr.isWord;
}
/** Returns if there is any word in the trie that starts with the given prefix. */
public boolean startsWith(String prefix) {
TrieNode curr = root;
for (char c : prefix.toCharArray()) {
int index = c - 'a';
if (curr.children[index] == null) {
return false;
}
curr = curr.children[index];
}
return true;
}
private static class TrieNode {
private TrieNode[] children;
private boolean isWord;
public TrieNode() {
children = new TrieNode[26];
}
}
}
212. Word Search II
给定一个二维数组和单词表，在数组中查找出现的单词。注意单词只要是相邻的字母构成的就可以，方向上下左右都可以，也允许弯折。
我的解法
- 首先需要解决单词表的问题，这里不能使用 Set，必须使用 TrieTree，因为搜索的时候要逐个增加字母再去匹配，使用 TrieTree 更合适；
- 使用 Set path 记录已经使用的位置；
- 记录当前已经拼成的单词为 curr。
class Solution {
public List<String> findWords(char[][] board, String[] words) {
if (board.length == 0 || board[0].length == 0)
return Collections.emptyList();
Trie trie = new Trie();
for (String word : words)
trie.add(word);
Set<String> result = new HashSet<>();
Set<String> path = new HashSet<>();
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[0].length; j++) {
path.clear();
search(board, trie, result, path, "", i, j);
}
}
return new ArrayList(result);
}
private void search(char[][] board, Trie trie, Set<String> result, Set<String> path, String curr, int row, int col) {
if(path.contains(row + "," + col))
return;
curr += board[row][col];
if(trie.search(curr))
result.add(curr);
if(trie.startsWith(curr)) {
String location = row + "," + col;
path.add(location);
if(row > 0)
search(board, trie, result, path, curr, row - 1, col);
if(row + 1 < board.length)
search(board, trie, result, path, curr, row + 1, col);
if(col > 0)
search(board, trie, result, path, curr, row, col - 1);
if(col + 1 < board[0].length)
search(board, trie, result, path, curr, row, col + 1);
path.remove(location);
}
}
static class Trie {
Node root = new Node();
void add(String word) {
Node curr = root;
for (char c : word.toCharArray()) {
int i = c - 'a';
if (curr.children[i] == null)
curr.children[i] = new Node();
curr = curr.children[i];
}
curr.isWord = true;
}
boolean startsWith(String prefix) {
Node curr = root;
for (char c : prefix.toCharArray()) {
int i = c - 'a';
if (curr.children[i] == null)
return false;
curr = curr.children[i];
}
return true;
}
boolean search(String word) {
Node curr = root;
for (char c : word.toCharArray()) {
int i = c - 'a';
if (curr.children[i] == null)
return false;
curr = curr.children[i];
}
return curr.isWord;
}
private static class Node {
boolean isWord;
Node[] children = new Node[26];
}
}
}
大神的解法
解法非常牛逼，总体思路上和上面是一致的，但是细节处理的很好，虽然我写的一次性AC兴奋了半天，但是有几点还是比大神差了很多。
- TrieTree 其实不需要完整的实现，融合到搜索的过程中即可，否则会增加很多重复计算；
- 如何记录已经使用过的位置？可以用一个 Set，位置保存为类似 row + "," + col 的样式，用来判重，但是大神给出了更简单的方式，直接将对应的位置字母替换为 # 即可，记得用完之后要设置回来，回溯嘛；
- 每个 Node 可以保存它对应的单词，如果没有就是 null，这样就避免了计算过程中需要传递当前搜索到的单词的麻烦；
- 题目要求结果不能重复，可以使用 Set 存储最后再转换为 List，但大神的解法是添加完单词后，将 node 中保存的 word 去掉，这样就避免了重复。
综上，膜拜大神！
class Solution {
public List<String> findWords(char[][] board, String[] words) {
if (board.length == 0 || board[0].length == 0)
return Collections.emptyList();
TrieNode root = new TrieNode();
for (String word : words) {
TrieNode curr = root;
for (char c : word.toCharArray()) {
int i = c - 'a';
if (curr.children[i] == null)
curr.children[i] = new TrieNode();
curr = curr.children[i];
}
curr.word = word;
}
List<String> result = new ArrayList<>();
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[0].length; j++) {
search(board, root, result, i, j);
}
}
return result;
}
private void search(char[][] board, TrieNode node, List<String> result, int row, int col) {
char c = board[row][col];
if(c == '#' || node.children[c - 'a'] == null) return;
node = node.children[c - 'a'];
if(node.word != null) {
result.add(node.word);
node.word = null;
}
board[row][col] = '#';
if(row > 0)
search(board, node, result, row - 1, col);
if(row + 1 < board.length)
search(board, node, result, row + 1, col);
if(col > 0)
search(board, node, result, row, col - 1);
if(col + 1 < board[0].length)
search(board, node, result, row, col + 1);
board[row][col] = c;
}
private static class TrieNode {
String word;
TrieNode[] children = new TrieNode[26];
}
}
位运算
整数的原码、反码、补码都一样，负数的表示：
原码：第一位表示符号位，后面的位表示数值；
反码：第一位表示符号位，后面各位为原码取反；
补码：反码加1
| 原码 | 反码 | 补码 | |
|---|---|---|---|
| 100 | 0110 0100 | 0110 0100 | 0110 0100 |
| -100 | 1110 0100 | 1001 1011 | 1001 1100 |
常用技巧：
x ^ 0 = x
x ^ 1s = ~x //1s表示所有位都是1
x ^ (~x) = 1s
x ^ x = 0
交换两个变量：a = a ^ b; b = a ^ b; a = a ^ b;
a ^ b ^ c = a ^ (b ^ c)
x & 1 == 0 或 1 => 判断奇偶，也适用负数
x = x & (x - 1) => 清空最低位的1，也适用负数
x & -x => 得到最低位的 1，也适用负数
191. Number of 1 Bits
数1的个数
位移法
注意是无符号右移，否则如果 n 为负数结果就是错的。
public class Solution {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {
int count = 0;
while(n != 0) {
count += n & 1;
n >>>= 1;
}
return count;
}
}
消减法
利用 n & (n - 1) 可以消除最低位 1 的特性。
public class Solution {
// you need to treat n as an unsigned value
public int hammingWeight(int n) {
int count = 0;
while(n != 0) {
n &= n - 1;
count++;
}
return count;
}
}
231. Power of Two
338. Counting Bits
class Solution {
public int[] countBits(int num) {
int[] res = new int[num + 1];
int pow = 1;
for(int i = 1; i <= num; i++) {
if ((i & (i - 1)) == 0) {
res[i] = 1;
pow = i;
} else {
res[i] = res[i - pow] + 1;
}
}
return res;
}
}
class Solution {
public int[] countBits(int num) {
int[] res = new int[num + 1];
for(int i = 1; i <= num; i++) {
res[i] = res[i >> 1] + (i & 1);
}
return res;
}
}
class Solution {
public int[] countBits(int num) {
int[] res = new int[num + 1];
for(int i = 1; i <= num; i++) {
res[i] = res[i & (i - 1)] + 1;
}
return res;
}
}
动态规划
70. Climbing Stairs
爬楼梯，一次只能一阶或者两阶。
第 n 阶肯定是从第 n - 1 阶或者第 n - 2 阶然后登了一下上来的，这样考虑就是斐波那契问题了。
注意 DP 中有个很重要的思维方式，把从顶向下改为从底向上，能减少缓存的使用。
class Solution {
public int climbStairs(int n) {
int f0 = 1, f1 = 1, tmp;
while(n-- > 1) {
tmp = f1;
f1 += f0;
f0 = tmp;
}
return f1;
}
}
120. Triangle
给定一个数字组成的三角形，求从顶部到底部所有路径中最小的和。
这是个 DP 的问题，有两个点要注意：
- 从上到下计算的话，最终会生成 n 个值，再取最小值，不如从下到上计算，结果只有一个；
- 不需要用二维数组记录，因为每一次只会用到前一行的值，使用一位数组就够了。 DP 保存中间状态时，考虑两个问题，一个是中间状态足够计算下一步，一个是中间状态能得出最终结果，只要满足这两个条件，中间状态的数据结构越简单越好。有时候二维的问题可以用一维存储中间状态，一维的问题用一两个变量保存中间状态。这种做法叫做状态压缩。
class Solution {
public int minimumTotal(List<List<Integer>> triangle) {
int[] dp = new int[triangle.size() + 1];
for (int i = triangle.size() - 1; i >= 0; i--)
for (int j = 0; j <= i; j++)
dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
return dp[0];
}
}
152. Maximum Product Subarray
求乘积最大的子串。注意给定数组 nums 是 int 类型，但有可能会是负数。
朴素的 DP 解法
计算所有从 j 到 i 的数的乘积，统计其最大值，使用一维数组保存来减少重复计算。时间复杂度为 O(N2)，空间复杂度为 O(N)。
class Solution {
public int maxProduct(int[] nums) {
int max = nums[0];
int[] dp = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < i; j++) {
dp[j] *= nums[i];
max = Math.max(max, dp[j]);
}
dp[i] = nums[i];
max = Math.max(max, dp[i]);
}
return max;
}
}
更简单的 DP
首先是递推公式，记以第 i 个元素结尾的子串最大乘积为 max(i)，最小乘积为 min(i)。那么 max(i) 应该取 nums[i]、nums[i) * max[i - 1]、nums[i] * min(i - ) 之中的最小值，所以保存状态需要包含最大值和最小值。另外最后一种情况仅当 nums[i] 为负数时发生，所以可以通过判断 nums[i] 是否为负数进行特殊处理，交换最小最大值。
class Solution {
public int maxProduct(int[] nums) {
int res = nums[0];
for (int i = 1, max = res, min = res; i < nums.length; i++) {
int tmp = Math.max(Math.max(nums[i], nums[i] * max), nums[i] * min);
min = Math.min(Math.min(nums[i], nums[i] * max), nums[i] * min);
max = tmp; //不要直接修改 max 值，否则 min 就没法计算了
res = Math.max(max, res);
}
return res;
}
}
class Solution {
public int maxProduct(int[] nums) {
int res = nums[0];
for (int i = 1, max = res, min = res; i < nums.length; i++) {
if (nums[i] < 0) {
int tmp = max;
max = min;
min = tmp;
}
max = Math.max(nums[i], nums[i] * max);
min = Math.min(nums[i], nums[i] * min);
res = Math.max(max, res);
}
return res;
}
}
121. Best Time to Buy and Sell Stock
买卖股票I，只能买入卖出一次，min 记录 i 之前的最低价格，在 i 时卖出的最大价格应该是 i - min。
买卖股票II是贪心问题，前面已经有了。
class Solution {
public int maxProfit(int[] prices) {
int max = 0, min = Integer.MAX_VALUE;
for (int i : prices) {
min = Math.min(min, i);
max = Math.max(max, i - min);
}
return max;
}
}
123. Best Time to Buy and Sell Stock III
买卖股票III，只能买卖两次
简单粗暴的解法
分为前半部分和后半部分，每一部分的求解方法和只能购买一次相同
class Solution {
public int maxProfit(int[] prices) {
int min, m1, m2, max = 0;
for (int i = 0; i < prices.length; i++) {
m1 = 0;
m2 = 0;
min = prices[0];
for (int j = 1; j < i; j++) {
min = Math.min(min, prices[j]);
m1 = Math.max(m1, prices[j] - min);
}
min = prices[i];
for (int j = i + 1; j < prices.length; j++) {
min = Math.min(min, prices[j]);
m2 = Math.max(m2, prices[j] - min);
}
max = Math.max(m1 + m2, max);
}
return max;
}
}
DP 解法
这个算法参考大神的答案，非常不好理解，解释一下这几个变量： b1 表示买入一次的最低价格，s1 表示卖出一次的最高获利，b2 表示第二次买入的最低价格，可以理解为卖出第一次后再买入第二次后的获利总和，s2 表示第二次卖出后最大获利。
class Solution {
public int maxProfit(int[] prices) {
if (prices.length < 2)
return 0;
int b1 = Integer.MAX_VALUE;
int s1 = 0;
int b2 = Integer.MAX_VALUE;
int s2 = 0;
for (int p : prices) {
b1 = Math.min(b1, p);
s1 = Math.max(s1, p - b1);
b2 = Math.min(b2, p - s1);
s2 = Math.max(s2, p - b2);
}
return s2;
}
}
188. Best Time to Buy and Sell Stock IV
允许进行至多 K 次交易。 这个题目和上面的题目思路是一样的。
class Solution {
public int maxProfit(int k, int[] prices) {
if (prices.length <= 1)
return 0;
if (k >= prices.length) {
int res = 0;
for (int i = 1; i < prices.length; i++) {
res += Math.max(0, prices[i] - prices[i - 1]);
}
return res;
}
int[] buy = new int[k + 1];
int[] sell = new int[k + 1];
for (int i = 0; i <= k; i++)
buy[i] = Integer.MAX_VALUE;
for (int p : prices) {
for (int i = 1; i <= k; i++) {
buy[i] = Math.min(buy[i], p - sell[i - 1]);
sell[i] = Math.max(sell[i], p - buy[i]);
}
}
return sell[k];
}
}
