207.课程表
现在你总共有 n 门课需要选，记为 0 到 n-1。在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？
示例 1:输入: 2, [[1,0]],输出: true,解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:输入: 2, [[1,0],[0,1]]输出: false,解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成?课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
分析：这个问题相当于查找一个循环是否存在于有向图中，可使用BFS/DFS，本体先使用BFS，易于理解。如何判断一门课程能够学习--这门课程不用先修课程，或者先修课程已经完成，我们将已经修完的课程直接抛弃参与以后的讨论。一门课程的先修课程数即使‘’入度‘，当入度为0时，就说明这门课程可以完成，所以我们首先创建一个degree数组存储每门课程的入度。当一个有向图中不存在环，那么刚开始时肯定有一个入度为0，即没有先修课程的课程。我们以此课程进行广度遍历。没遍历到一门课程，那么说明此条路径可达，那么这门课程的入度减一，如果入度变为0，说明此课程不在环内，待完成课程数减一。最后查看待完成课程是否为0.如何实现遍历呢，使用队列，先进先出
实例：degree[] = {0 ,0 ,1, 1, 2, 1}
以课程1为出发点遍历有序图，将课程1放入队列。此时栈内：1
出栈，遍历prerequisites[][]，发现课程2的先修课程是1，那么就将degree[2] -1，此时degree[2]=0，那么说明2入度为0，可完成，入栈。此时栈内：2
出栈，遍历prerequisites[][]，发现课程3的先修课程是2，那么就将degree[3 ]-1，此时degree[3]=0，那么说明3入度为0，可完成，入栈。此时栈内：3
（此处不用出栈，因为还在以课程2为入度的循环内）遍历prerequisites[][]，发现课程4的先修课程是2，那么就将degree[4] -1，此时degree[4]=1，那么说明4入度为0，可完成，入栈。此时栈内：3，4
出栈，遍历prerequisites[][]，发现课程5的先修课程是3，那么就将degree[5 ]-1，此时degree[5]=1，那么说明5入度为1，不可完成。此时栈内：4
出栈，遍历prerequisites[][]，发现课程5的先修课程是4，那么就将degree[5 ]-1，此时degree[5]=0，那么说明5入度为0，可完成。入栈，此时栈内：5
出栈，遍历prerequisites[][]，发现没有以5为先修课程的，那么结束循环。此时队列也为空，那么结束循环。判断此时待修课程是否为0；
1 class Solution {
2 public boolean canFinish(int numCourses, int[][] prerequisites) {
3 //计算入度数组
4 int[] degree = new int[numCourses];
5 for(int[] cp : prerequisites){
6 degree[cp[0]]++;
7 }
8 //存放入度为0课程
9 LinkedList<Integer> queue = new LinkedList();
10 //找出入度为0的课程
11 for(int i=0;i<numCourses;i++){
12 if(degree[i]==0) queue.addLast(i);
13 }
14 //找到下一个入度为0的
15 while(!queue.isEmpty()){
16 //出栈，能够完成的课程
17 Integer pre = queue.removeFirst();
18 numCourses--;
19 for(int[] req : prerequisites){
20 if(req[1] != pre) continue;
21 degree[req[0]]--;
22 if(degree[req[0]] == 0) queue.addLast(req[0]);
23 }
24 }
25 return numCourses==0;
26 }
27 }
208.实现Trie（前缀树）
实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。
示例:
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple"); // 返回 true
trie.search("app"); // 返回 false
trie.startsWith("app"); // 返回 true
trie.insert("app");
trie.search("app"); // 返回 true
分析：Trie根节点不存入值
1.Trie节点结构：一个int[26]数组来存储字符值，一个boolean类型is_end判断是否以该字符结尾。下图表示leet在树中的表示。
2.插入：插入一个值，从根部开始搜索字符值，存在两种情况：
链接存在：继续向下搜索
链接不存在：创建新节点，直到达到插入值最后一个字符，将末尾字符is_end设置为true
3.查找：
4.前缀
1 class TrieNode{
2 TrieNode[] chiled;//记录孩子节点
3 boolean is_end;
4 TrieNode(){
5 chiled = new TrieNode[26];//一个孩子节点有2266个分支，即一层树有26各分支
6 is_end = false;
7 }
8 }
9 class Trie {
10 TrieNode root;//根节点，不存值
11 /** Initialize your data structure here. */
12 public Trie() {
13 root = new TrieNode();
14 }
15
16 /** Inserts a word into the trie. */
17 public void insert(String word) {
18 TrieNode node = root;
19 for(int i=0;i<word.length();i++){
20 char c = word.charAt(i);
21 if(node.chiled[c-‘a‘]==null){//如果该层该字符位置为空,则新建一个
22 node.chiled[c-‘a‘] = new TrieNode();
23 }
24 node = node.chiled[c-‘a‘];//指向下一层
25 }
26 node.is_end = true;//字符串最后一个字符那层的位置is_end=true
27 }
28
29 /** Returns if the word is in the trie. */
30 public boolean search(String word) {
31 TrieNode node = root;
32 for(int i=0;i<word.length();i++){
33 char c= word.charAt(i);
34 if(node.chiled[c-‘a‘] == null){//判断是否存在
35 return false;
36 }
37 node = node.chiled[c-‘a‘];
38 }
39 return node.is_end;//判断结尾
40 }
41
42 /** Returns if there is any word in the trie that starts with the given prefix. */
43 /**
44 *serach和startWith区别在于是否判断结尾is_end，startWith是只要字符存在就行
45 */
46 public boolean startsWith(String prefix) {
47 TrieNode node = root;
48 for(int i=0;i<prefix.length();i++){
49 char c= prefix.charAt(i);
50 if(node.chiled[c-‘a‘] == null){//判断是否存在
51 return false;
52 }
53 node = node.chiled[c-‘a‘];
54 }
55 return true;
56 }
57 }
58
59 /**
60 * Your Trie object will be instantiated and called as such:
61 * Trie obj = new Trie();
62 * obj.insert(word);
63 * boolean param_2 = obj.search(word);
64 * boolean param_3 = obj.startsWith(prefix);
65 */
215.数组中最K个最大元素
示例 1:输入: [3,2,1,5,6,4] 和 k = 2，输出: 5
示例 2:输入: [3,2,3,1,2,4,5,5,6] 和 k = 4，输出: 4
分析：排序，输出nums[length-K]，快排O(NlogN)；复杂度不咋地，看了题解使用堆排序，维持一个大小为K的小顶堆，那么堆顶就是答案，如果大于堆顶且堆满就加入，反之不操作，复杂度为O(NlogK)。
1 class Solution {
2 public int findKthLargest(int[] nums, int k) {
3 //利用最小堆，创建k+1的size，遍历数组进行添加，并poll一个
4 PriorityQueue<Integer> heap = new PriorityQueue(k+1);
5 for(int num : nums){
6 heap.add(num);
7 if(heap.size() > k){
8 heap.poll();
9 }
10 }
11 return heap.poll();
12 }
13 }
221.最大正方形
在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。
示例:
输入: 1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 0 输出: 4
分析：动态规划，建立一个二维数组dp[i][j]，在左上角矩阵中由matrix[i-1][j-1]参与构成的最大正方形边长。
如果matrix[i-1][j-1]=‘1‘ => dp[i][j] = min{dp[i-1][j], dp[i-1][j-1], dp[i][j-1] } +1。否则 dp[i][j]=0。
1 class Solution {
2 public int maximalSquare(char[][] matrix) {
3 if(matrix.length == 0) return 0;
4 int rl = matrix.length;
5 int cl = matrix[0].length;
6 int[][] dp = new int[rl+1][cl+1];
7 int maxLen = 0;
8 for(int i=1;i<=rl;i++){
9 for(int j=1;j<=cl;j++){
10 if(matrix[i-1][j-1] == ‘1‘){
11 dp[i][j] = Math.min(dp[i-1][j-1], Math.min(dp[i-1][j],dp[i][j-1]))+1;
12 maxLen = Math.max(maxLen, dp[i][j]);
13 }
14 }
15 }
16 return maxLen*maxLen;
17 }
18 }
226.翻转二叉树
示例：
输入：
4
/ \
2 7
/ \ / \
1 3 6 9
输出：
4
/ \
7 2
/ \ / \
9 6 3 1
分析：递归
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 class Solution {
11 public TreeNode invertTree(TreeNode root) {
12 if(root == null){
13 return root;
14 }
15 TreeNode leftNode = invertTree(root.left);
16 TreeNode rightNode = invertTree(root.right);
17 root.left = rightNode;
18 root.right = leftNode;
19 return root;
20 }
21 }
迭代
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) return null;
Queue<TreeNode> queue = new LinkedList();
queue.add(root);
while(!queue.isEmpty()){
TreeNode node = queue.poll();
TreeNode temp = node.left;
node.left = node.right;
node.right = temp;
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
return root;
}
}
234.回文链表
请判断一个链表是否为回文链表。
示例 1:输入: 1->2输出: false
示例 2:输入: 1->2->2->1输出: true
分析：1.快慢指针，指向中间。2.将前半段倒序。3.遍历比较
1 /**
2 * Definition for singly-linked list.
3 * public class ListNode {
4 * int val;
5 * ListNode next;
6 * ListNode(int x) { val = x; }
7 * }
8 */
9 class Solution {
10 public boolean isPalindrome(ListNode head) {
11 if(head == null || head.next == null) return true;
12 ListNode cur = head;
13 ListNode slow = head, fast = head.next, pre = null, prepre = null;
14 while(fast!=null&&fast.next!=null){
15 pre = slow;//先保存slow
16 slow = slow.next;
17 fast = fast.next.next;
18 //先移动再反转
19 pre.next = prepre;
20 prepre = pre;
21 }
22 ListNode p2 = slow.next;//右边
23 slow.next = pre;
24 ListNode p1 = fast == null ? slow.next : slow;//如果是奇数个，则跳过中间节点
25 while(p1 != null){
26 if(p1.val != p2.val)
27 return false;
28 p1 = p1.next;
29 p2 = p2.next;
30 }
31 return true;
32 }
33 }
236.二叉树的最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
示例 1:输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1；输出: 3，解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4；输出: 5，解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
分析：递归，从根节点开始。如果存在公共祖先，所以要么是根节点，要么在左子树或右子树。如果根节点已经包含待求值中的某一值，则根节点一定是最早公共祖先（一个节点先遍历到，另一个节点是其祖先）。遍历过程中，存在三种情况：
- 如果左子树中没有待求值，但右子树中返回了某一节点值，则可判断右子树中存在公共子节点，而递归操作就可以达到查找到最早公共子节点的作用
- 如果左子树中返回每一节点，而右子树中为空，与上述情况相同
- 如果左右子树均有返回节点，则可判断左右子树中应分别有一个待求节点，故此时的根节点一定是最早公共祖先。
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 class Solution {
11 public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
12 if(root == null || root == p || root == q){
13 return root;
14 }
15 //根据当前节点寻找左右子树
16 TreeNode left = lowestCommonAncestor(root.left,p,q);
17 TreeNode right = lowestCommonAncestor(root.right,p,q);
18 //如果左子树有一个，右子树也找到一个，则返回当前节点
19 if(left!=null&&right!=null){
20 return root;
21 }
22 //左子树没有，那么去右子树找
23 if(left == null) return right;
24 //与上述相反
25 if(right == null) return left;
26 return null;
27 }
28 }
238.除自身以外数组的乘积
给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
示例:输入: [1,2,3,4],输出: [24,12,8,6]
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。
分析：暴力法不可取，O(N^2)。乘积 = 当前数左边乘积 * 当前数右边乘积。设置一数组，一次从头到尾遍历原数组存入左边乘值，一次从未到头遍历原数组存入右边乘值。例如：[1,2,3,4]
从前往后：[1，1*1， 2*1， 2*3]
从后往前：[1*2*3*4，1*1 * 3*4，2*1 * 4，2*3]
1 class Solution {
2 public int[] productExceptSelf(int[] nums) {
3 int[] res = new int[nums.length];
4 int k = 1;
5 for(int i=0;i<nums.length;i++){
6 res[i] = k;//[1,1,2,6]
7 k *= nums[i];//[1,2,6,24]给下次乘值使用，这样就是i左边的乘值
8 }
9 k = 1;
10 for(int i=nums.length-1;i>=0;i--){
11 res[i] *= k;//[24,12,8,6]
12 k *= nums[i];//[24,24,12,4] i右边的乘值
13 }
14 return res;
15 }
16 }
239.滑动窗口最大值
给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。
示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3，输出: [3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
提示：你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。
分析：双向链表：剑指Offer；
Step1.使用一个双端队列存储滑窗内元素的下标。
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
queue
Step2.若queue为空，说明刚开始滑动，将num第一个元素的索引压入队列中。
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
queue
| 0 |
Step3.遍历num下一个元素num[1]=3，
①先判断当前索引位置减去队列最左边元素是否>=size，如果是，那么说明随着滑窗滑动，当前滑窗内的最大值滑出去了，已经不再这个滑窗内，这是需要将队列最左边元素弹出。（队列最左边为滑窗内最大值索引，判断是否有效）
②将当前元素与队列最右边的索引处的数组值对比，如果当前元素大于队列最右边对应的值，则将队列最右边的值弹出，直到找到对应值比当前元素值大的。（队列左边是最大的值，随着上述操作，会逐渐更新队列，滑出去或者新添加的值更大的话将会更新队列，保证队头对应值最大）
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 1 |
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 2 |
---输出4
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 2 | 3 |
---输出4
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 4 |
---输出6
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 4 | 5 |
---输出6
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| 4 | 5 |
---输出6
| value | 2 | 3 | 4 | 2 | 6 | 2 | 5 | 1 |
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
--当前索引处位置（7）-队列最左边（4）=size（3）--》滑出
| 4 | 5 | 7 |
--
| 5 | 7 |
--输出5
补充：队头是存储最大值的索引，队头被弹出的情况：新来的比队内所有数都大、队头不在当前子数组中。新来成员时，判断是否有老成员太老了和新成员是否比其他老成员大（循环比，大一个弹一个，直到队列为空或者比老成员小）。队内情况：索引由小到大，因为位于当前元素前面并且小的被淘汰了。
1 class Solution {
2 public int[] maxSlidingWindow(int[] nums, int k) {
3 if(nums==null||nums.length==0) return nums;
4 int len = nums.length;
5 int[] res = new int[len-k+1];
6 int index = 0;
7 ArrayDeque<Integer> queue = new ArrayDeque<Integer>();//队列存储的是索引值
8 for(int i=0;i<nums.length;i++){
9 if(queue.isEmpty()){
10 queue.add(i);//刚开始时
11 }
12 if(i-queue.peekFirst()>=k){
13 queue.pollFirst();//将太老的老成员提出
14 }
15 while(!queue.isEmpty() && nums[i]>=nums[queue.peekLast()]){
16 queue.pollLast();
17 }
18 queue.addLast(i);
19 if(i>=k-1){//k-1个元素开始，就要输出了
20 res[index++] = nums[queue.peekFirst()];
21 }
22 }
23 return res;
24 }
25 }
240.搜索二维矩阵Ⅱ
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：每行的元素从左到右升序排列。每列的元素从上到下升序排列。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。给定 target = 20，返回 false。
分析：矩阵特点：左上角最小，右下角最大。本题从左下角遍历，如果大于当前元素，则向右寻找，反之，向上寻找。复杂度O(n+m)。
1 class Solution {
2 public boolean searchMatrix(int[][] matrix, int target) {
3 if(matrix == null || matrix.length ==0 || matrix[0].length == 0){
4 return false;
5 }
6 int m = matrix.length;
7 int n = matrix[0].length;
8 int row = m-1, col = 0;
9 while(row >= 0 && col <= n-1){
10 if(matrix[row][col] == target){
11 return true;
12 }else if(matrix[row][col] < target){
13 col++;
14 }else{
15 row--;
16 }
17 }
18 return false;
19 }
20 }
原文地址：https://www.cnblogs.com/qmillet/p/12161319.html