类别1 数组(10)html
1. 二维数组中的查找java
(核心技巧：从一个角找起，每次放弃一行或一列)node
if...else这种仍是写括号的好，像这种git
if(target>array[i][j]){
j++;
}else{
i--;
}
不要简写，也不要写两个if，否则可能出错正则表达式
13. 调整数组顺序使奇数位于偶数前面 (插排)算法
(核心技巧：插排)api
两种解法：解法1：空间替代时间 解法2：插排的思想数组
遇到一道难题，当想不出来特别好的解法，或者想到一个思路，不知道怎么作时，能够想一想暴力解法，有没有能够解决的，最起码比解不出来强。变量名必定不要写错，题目给出的变量或者前面本身定义的变量，必定要写对。array=arr，这样写不行，要把arr里的数遍历一遍，赋值给array。缓存
28. 数组中出现次数超过一半的数字数据结构
(核心技巧：消除法及其应用)
两种解法：解法1：利用库函数排序，而后找到中间的数，而后判断它是否是出现次数超过一半的数。O(nlogn)。解法2：利用消除法找到可能的目标数字，利用times记录数字出现的次数，result记录数字，若是数组中不存在目标数字，那么无所谓，反正最后还要判断，若是存在目标数字，那么result最终的结果必定是目标数字，再判断确认一下便可。0(n)
32. 把数组排成最小的数
核心技巧(利用数组排序；比较器的使用；比较方法的正确选择)
暴力解法，O(n!)还不会写
懂这个技巧就会，不懂就不会。固然，里面涉及到的知识点，如String.valueOf(),Comparator,Arrays.sort(),compare,compareTo等也得会。
Comparator在java.utils包中，覆写的方法应该是public(缘由)，sort()方法结束后应该写封号。
字符串之间不能用>
思路：新建一个字符串数组，把整数数组中的数字转化为字符串(String.valueOf(int))。而后对这个数组进行排序，规则(若str1+str2>str2+str1，则str1>str2)。最后，拼接整个数组的字符串为一个字符串，即为所求。
String -->
Integer.parseInt(str)
Integer.valueOf(str).intValue()
50. 数组中重复的数字(能够用hashMap)
HashMap能够解决，但空间复杂度会大。
一个技巧，数字在0-n-1之间，能够监控数字为下标位置上的数，出现第一次时，给它加length，第二次出现时就能够知道重复出现过了。注意数组改变过了，须要取余操做。
51. 构建乘积数组
能够用除法，是最简单的，一个for循环就够了，可是不让用；双重循环也比较好作，但时间复杂度高；最好的方法是上三角、下三角那样作，纯技巧，记得就会，不记得就不会。
leetcode1 两数之和
hashmap很好的使用例子，能够再o(n)时间内解决，API，hashmap.containsKey(()
leetcode11 盛最多水的容器
笔试题应该不会考，暴力解o(n^2)， 双指针，i, j，但没想到怎么用双指针，技巧是左边低，i++,右边低，j--
leetcode31 下一个排列
笔试可能会考
思想：一个数组，从右向左，若是一直是升序的，就是字典序最大的，因此要找到第一个i和i+1,使得nums[i]
注意点，reverse(nums,i)，交换的是j和nums.lenth+i-1-j，条件是2*j
注意找到的是i和i+1，使得nums[i]
leetcode 搜索选择排序数组：
笔试考的几率不大，由于o(n)就找完了
思想：二分查找，start, end, mid, 如target == nums[mid] return mid ,不然若是start，mid有序，在start,mid-1找，不然在mid+1,end找，若是mid+1到end有序，在mid+1，end找，，不然在start,,mid-1找，mid左右总有一个是有序的，因此总能无遗漏的找完。
leetcode48 旋转图像
将题目转化为转置+行逆排
letcode55 跳跃游戏
定义一个变量max,初始化为0，表明当前所能达到的最大位置，从0开始，若是一个位置可以到达，就尝试更新max,直到max>length-1,或者遍历到头或某位置不可到达。
leetcode56 合并区间
定义一个数组res，遍历intervals，若是遍历到的arr中，arr[0]>res[i][1],则res中新加一个，不然尝试更新res中最右一侧数组的边界。
类别2 字符串(9)
2. 替换空格
StringBuffer API及StringBuffer与String相互转化。
27. 字符串的排列
String与字符数组相互转化。看位置，每一个位置上，每一个元素都出现过一次，是完整的全排列。递归。
leetcode17 电话号码的字母组合
9个数字，每一个数字各表明三个字母
第一步：定义HashMap,键为数字，值为对应的字符串
第二步：定义结果集，等待添加结果
第三步：定义辅助函数helper(int digital, int result)，若是digital长度为0，则说明result已经从每一个数字表明的字符串中拿到了一个字母，能够返回结果了；不然，利用digital.substring(0)从HashMap中拿到字符串，遍历字符串，每次执行helper(int digital.substring(1), int result)。
第四步：在给出的函数中调用helper(digital, "");,返回第二步的结果集。
34. 第一个只出现一次的字符位置
思路：用hashMap或者数组(65-90，97-122)等记录记录下，字符串中元素出现的次数。后续有两种方法，能够得到第一个出现一次的方法：1)遍历全部只出现一次的元素，看谁排在前面(indexOf(),charAt())2)从头到尾遍历字符串元素，看哪一个
是出现一次的。Integer.min()很好用。导入HashMap不能直接用Map，还得导入Map。反之也不能够
43. 左旋转字符串
三种思路：1)数组 2)三次反转 3)StringBuilder，注意StringBuilder是lang包中的，lang包不须要导入，substring(a,b)(不包含b),append(StringBuilder),构造函数可使用String作参数,StringBuilder sb，sb.length()。
44. 翻转单词顺序
思路：字符串利用split(" ")转化为字符串数组，而后用一个循环(i=arr.length-1;i>0;i--)，转成新的字符串。str.trim()去点字符串两端的空格。
49. 把字符串转换成整数
long转int，要强转，int转long不须要，int转char要强转，char转int不须要，可是’9‘到9，要减去’0‘
52. 正则表达式匹配
递归判断
1)字符串和模式串都到头，成功
2)字符串没到头，模式串到头，失败
3)若是模式串下一个字符是*，
那么若是字符串和模式串当前匹配，那么有三种状况，模式串匹配当前字符，模式串匹配0个字符，模式串匹配当前字符后，继续匹配下一个字符。若是字符串和模式串不匹配，模式串只匹配当前字符。
若是模式串下一个字符不是*，有两种状况，模式串匹配当前字符，都进行下一个；若是不匹配，直接失败。
细节：.*能够是无数点的意思，能够匹配任意字符串。 若是模式串下一个字符是*，而字符串已经越界，是不匹配的，即‘’是不匹配'.'这样能够说的通，若是匹配，matchHelper(str,pattern,strIndex+1,patIndex)会一直走下去，并且其余的条件也可能越界，固然也有可能能够匹配，只是我对题目找到没理解透彻，没找到好方法。
3. 表示数值的字符串
1)java中的&& || 2)为何个人事错的？？？？？？？？？？？？？？？？？？
54. 字符流中第一个不重复的字符
1) int转char怎么转，转过去值是怎么变的 2)hashMap的用法，不仅是能记录是不是1，还能记录哪一个最早出现，这样能够下降空间复杂度 3)java中char到底占几个字节，char的范围是多少，汉子怎么算？？？？？？？？？？
leetcode 121 买卖股票的最佳时机
记录一个历史最小值(不是全局最小值)，而后用当前值减历史最小值，其实也不难，但为何想不到呢？
leetcode 3 无重复字符的最长子串
基本上不会做为笔试题，由于暴力方法也很快，技巧是i,j，随着i递增，j也在递增，j不须要从i开始。
leetcode5 最长回文子串
笔试基本不会考，暴力解，O(n^3)，比较好写。找到2n-1个中心点，不断寻找回文子串，记录最大值。
KMP算法
KMP算法 匹配的时候，当不匹配发生时，重点是指向主字符串的i指针不变，而模式串根据next数组向前移动。
求next数组时，关键是知道next[i-1]后，求next[i]时，能够根据p[i]与p[next[i]]相等来进行计算，减小计算过程。
类别3 链表(8)
3. 从头至尾打印链表
从头到尾放到arrayList里,用Collections.reverse()逆置一下。
14. 链表中倒数第k个结点
能够先遍历一遍，记录下结点个数，而后再计算倒数第k个结点，也能够找两个结点，p先跑k-1步，q再跑，这样q就只跑了n-k+1步，正好是倒数第k个结点的位置。
15. 反转链表
设置两个结点p,q，一前一后，就能够了
16. 合并两个排序的链表
归并排序的一部分，比较简单
25. 复杂链表的复制
三步走策略，具体见牛客网，记住了就会，记不住就O(N2)
36. 两个链表的第一个公共结点
两个链表呈Y字形
46. 圆圈中最后剩下的数(抽线建模能力)
用数组和HashMap是最蠢的
能够用链表(自定义节点)，不难写
也能够用Linkedlist，比较好写
55. 链表中环的入口结点
1)快慢指针，快的必定能够追上慢的，且差几格，就走几步。2)同速指针，相遇在入口结点
56. 删除链表中重复的结点
1)删掉全部重复出现的结点而不是去重。2)能够加一个头节点做为辅助结点3)排序的
leetcode234 回文链表
O(n) 时间复杂度，O(1) 空间复杂度 将链表后半段反转，而后与前半段比较，看是不是回文链表。回文数组，双指针更简单一些。
leetcode2 两数相加
我第一次作法：将两个链表反转，而后转为数字，而后相加，而后再转为链表，而后反转，挺麻烦的，并且问题是不少数字超过int范围，甚至超过long的范围。
正确作法是直接将两个链表相加，产生节点和进位
leetcode148 排序链表
第一点是用快慢指针找到中间节点的方法；第二点是归并排序对链表进行排序的方法；第三点是merge过程利用ListNode h = new ListNode(0)简单地进行归并。
类别4 树(15)
4. 重建二叉树
1)中序，先序肯定树结构的方法 2)递归
17. 树的子结构
首先递归遍历树A，看哪一个结点多是B的根节点，若是多是，递归判断。两个递归。
18. 二叉树的镜像
递归的交换二叉树的左右结点
层次遍历，主要考察队列API
Queue queue = new LinkedList<>();
queue.offer(root);
TreeNode node = queue.peek();
queue.poll();
23. 二叉搜素树的后序遍历序列
二叉搜素树，又称二叉排序树，和前面几道题思路差很少，递归遍历、判断。
24. 二叉树中和为某一值的路径
1)某节点是不是根节点
if(root.left == null && root.right == null)
2)回到上一层时，将arrayList中最后一个元素移除
arrayList.remove(arrayList.size()-1);
3)Comparator比较器,compare
26. 二叉搜索树与双向链表
两种方法，一种是递归方法，一种是非递归方法。递归方法能够设置一个队列，中序遍历，将结点都进队，就是有序的，而后一个个出队，这样就OK，这个其实不太好，由于这个用到了递归，用中序遍历非递归写法较好。一种是递归方法，中序遍历，先处理左子树，根节点左子树指向左子树最右结点，而后处理右子树，根节点右指针指向右子树最左节点。返回左子树最右结点。
38. 二叉树的深度
递归，两种思路，一种是简单的，返回左子树和右子树值较大的值加1，做为结果，注意递归记录递归的结果，不要再去递归一遍，不然时间复杂度会高不少。一种稍复杂，找一个全局变量，记录最大值，遇到叶子节点就判断是否更新全局变量，设置一个dpth，进到这个结点加1，遍历左右子树出这个结点时，减1。
39. 平衡二叉树
后续遍历，这样不会出现重复求子树高度的问题。高度和子树是不是平衡二叉树能够用一个变量来表示，若是子树不是平衡二叉树，那就返回-1，反则返回高度。
57. 二叉树的下一个结点
二叉树的下一个结点，有三种状况，有右子树，那就是右子树最左结点。没有右子树，有父节点的话，若是是父节点的左孩子，就是父节点。若是不是，就往上找，若是某个祖先结点是其父节点的左孩子，就是这个祖先结点的父节点。若是上述状况都不适合，就是null。
58. 对称的二叉树
对称的二叉树必定是彻底二叉树，只要对称位置的两个结点值相等就能够了。因此递归判断对称位置的结点是否相同。两个结点的值要相等，左节点的左子树要和右节点的右子树相等，左节点的右子树要和右节点的左子树相等。
59. 按之字形顺序打印二叉树
两个栈，将根节点入栈1，而后在两个栈不全空的状况下循环，标志位flag为奇数，就将1中元素出栈，并将左右节点入栈2，而后将出栈的元素按要求放入返回结果中。flag为2反之，直到两个栈全空。
60. 把二叉树打印成多行
同59，且比59简单。
61 序列化二叉树
序列化二叉树：用一个StringBuffer,先序遍历，把根节点放进去，而后分别添加左子树和右子树
反序列化二叉树：先序遍历，用一个int表征遍历到的数字，由于遍历的顺序就是二叉树节点先序的顺序，因此能够经过先序遍历建树。由于是先序遍历，不会产生flag越界的状况。这个方法能够用来利用数组等创建二叉树。
62. 二叉搜索树的第k个结点
中序遍历的结果就是二叉搜索树从小到大的结果，因此用一个int flag表征遍历到的数字，flag == k时，就是结果。
leetcode437 路径总和iii
1.递归的思想，一棵树，结果是头节点+左节点+右节点；
2.一种target-val的思想，两数和的问题也是这种思想。
leetcode543 二叉树的直径
后序遍历比较好
leetcode538 把二叉搜索树转化为累加树
反中序遍历 右-中-左
leetcode617 合并二叉树
两个树的遍历，同时遍历两个树，而后分别判断是否为空，为空则返回另外一个，两个都为空，就会返回空，不空相加，而后，去作左子树和右子树。
leetcode94 二叉树的中序遍历、前序遍历、后续遍历
递归写法很简单，而非递归方法有点难，前序遍历
前序遍历和中序差很少，以三个节点的树思考，区别在于前序是进栈时将其添加入结果中，而中序是出栈时添加
后序遍历，一个栈，一个LinkedList，队列用来存放结果，先将头节点放进队列里，而后逐次插入右和左，这样就是左、、右、中了。
leetcode98 验证二叉搜索树
1. helper(root, left, right)这样能保证某个节点不光大于(小于)父节点，并且也小于(大于)再上面的节点。
2.当想找一个初始的最小(最大值)时，能够不用Integer.MAX_VALUE，而把它设置为Integer类型的null,在不为null时比较，null时更新，这样就能避免真的等于MAX_VALUE的问题。
leetcode 114二叉树展开为链表
设置一个pre=null， 按后、中、头的顺序遍历，每一个节点right指向pre节点，left指向null, pre=当前节点(二叉树的全部指针恰好构成一个双向链表，单向链表要舍弃一半的节点)
类别5 栈和队列(4)
5. 用两个栈实现队列
util包中数据结构大小用size()
20. 包含min函数的栈
辅助栈
21. 栈的压入、弹出序列
利用辅助栈；遍历出栈序列，若是辅助栈为空，从入栈序列入栈一个数字，判断栈顶元素和出栈序列第i个数是否相等，不等的话入栈，直到相等或者入栈序列为空。若是相等了，出栈。若是是正确的出栈序列，最后栈会为空。黑线部分能够保证一个元素出栈，其以前的元素都已经入栈。
leetcode2 有效的括号
栈使用的很好的例子，不是全部元素都要入栈的，一部分元素入栈，另外一部分元素与栈顶元素判断(栈顶元素每每很敏感，看是否能消掉，最后每每会判断栈是否为空。
64. 滑动窗口的最大值
类别6 查找和排序(3)
6.查找和排序
37. 数字在排序数组中出现的次数(查找)
(核心技巧：二分查找)
二分查找的应用。二分查找，递归和循环都得会。稍微改进的二分查找，能够查到数字在排序数组中第一次出现的位置，也能够查到数字在排序数组中最后一次出现的位置。
29. 最小的K个数
利用大顶堆
最大的K个数，小顶堆
PriorityQueue maxHeap = new PriorityQueue<>(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
PriorityQueue minHeap = new PriorityQueue<>();
leetcode75 颜色分类
荷兰国旗问题，双指针两端遍历，i,j分别表明小于i的地方为0，j表明大于j的地方为1。cur从0开始遍历，若是等于0，和i交换，i++,cur++，若是等于1，cur++，若是等于2，与j交换，cur不变，j--。
类别7 递归和循环(5)
关键1 寻找递归结束条件 ；2 寻找后面的值如何由前面的计算获得
7.斐波那契数列
斐波那契数列从第0项开始：第0项，0；第1项1，第2项1，...，
8.跳台阶
普通题目，但是在leetcode上递归没法经过，由于递归时间复杂度较高，要用循环，经过循环计算出总数目
9.变态跳台阶
主要在于n怎么从n-1或n-2等获得，这个题目是f(n)=2*f(n-1)这个还挺难像的
10. 矩形覆盖
难点与9相同，这个是斐波那契序列的规则
47. 求1+2+3+...+n
这个难点在递归结束的条件，经过逻辑短路来结束循环
类别 8 位运算(3)
11. 二进制中1的个数
数字循环右移，与1作&运算，直到结束；
40. 数组中只出现一次的数字(位运算 或hashMap)
位运算解决：异或整个数组，求出两个只出现一次的数字的异或结果，写一个函数，找出异或结果右起第一个为1的位置，异或结果为1，说明这两个数字在这一位上不相同。根据这个特色，将数组中的数分为两组，分别异或，就能够求出这个数了。
注意：
判断某数字最后一位是否为1，num & 1 == 1，true为1，不然为0;是否为0 num & 1 == 0，true为0，不然为1。
数组中只出现一次的数字若是只有一个，其余数字出现偶数次，那么更好算了，异或一次就能够了。
48. 不用加减乘除作加法
同位相加不考虑进位，作异或运算；作&运算左移，计算进位，二者再相见，直到没有后者，前者就是结果
类别9 数据流(1)
63. 数据流中的中位数
类别10 回溯法(2)
65. 矩阵中的路径
回溯法的应用，从一个点开始，向四周发散，不断试探，直到成功，或者不成功返回false
这道题，循环遍历数组，试一下从这个点开始，是否能走通，能走通返回true，直到全部点都试一遍。须要一个数组记录这个点是否走过。
rows行，cols列的数组，以一维表示时，(i,j)在数组中下标为arr[i*cols+j]
66. 机器人的运动范围
回溯法的应用，这道题，从(0，0)开始，不断试探，是否符合条件或者是否走过，走过返回0，不符合条件返回0，不然返回1+这个节点上下左右。
leetcode39 组合总和
回溯+剪枝；
leetcode46 全排列
回溯的应用，很差判断的就是这个数是否在这个结果中了，用contains能够判断，但时间复杂度较高，因此可用官方题解里的一些方法。
leetcode49 字母异位词分组
这个挺好玩，每一个单词转为26个字母每一个字母出现次数的字符串，做为键，值为相同键的字符串，返回new ArrayList(hashMap.values())(将java.util.HashMap$Values转为java.util.ArrayList)。
leetcode79 单词搜索
遍历二维数组每一个位置，从每一个位置开始，各方向尝试并回溯，注意不是到达长度才去比较，是每一个位置都比较，尽快回溯。
directions, inArea, flag
leetcode200 岛屿数量
方法与79类似，遍历二维数组每一个位置，若是这个位置没被遍历过，且值为0，则将总数加1，不然遍历下一个；遍历的话，利用directions深度优先搜索，把联通的位置都遍历一遍。
类别11 滑动窗口(2)
41. 和为S的连续正数序列
滑动窗口，i=1,j=2,小于value,j++，大于value,i++,直到i==j
42. 和为S的两个数字
滑动窗口，从两端滑，直到碰到符合条件的
类别12 动态规划(3)
67. 剪绳子
数学方法：对3取余，根据余数不一样，加不一样个数的2；
动态规划：dp[i]，表示i绳子为i时的最大值，返回dp[n]便可。
30. 连续子数组的最大和
记得道题的技巧，就会作这道题，不然，就只能用暴力解了。
想到两种方法：1.暴力解，0(n^3);2.见牛客网解法，若是加到这个数字时的和尚未这个数字大，那么就把sum赋值为这个数字。
leetcode 152 乘积最大子数组
和连续子数组的最大和最大的区别是，不能用一个值来表明i以前的最大值，由于乘法有正负，因此须要一个max表明以前的最大值，min表明以前的最小值，而后包含当前元素的子数组的最大值为max(nums[i]*max,nums[i]*min,nums[i]),最小值为min(nums[i]*max,nums[i]*min,nums[i]),用res记录全局最大值，最后返回res便可。
leetcode139 单词拆分
典型的动态规划，dp[i]表示i位置以前的字符串能够被拆分，空字符串默承认以被拆分，因此dp[0]=true，而后判断dp[i]时，若是j(0<=j
leetcode198 打家劫舍
f(k) = max(f(k – 2) + A_k, f(k – 1))
f(k)第k户的最大收入。A_k第i户的收入，假设k=0和-1时f(k)为0，k从1开始
leetcode62. 不一样路径
方法1是从arr[0,0]开始，不断向下或 向右移动，若是能到达右下角，加1，可是这个方法时间复杂度过高； 还有一种方法是动态规划，上边一行和左边一列都是0，且arr[i][j] = arr[i-1][j]+arr[i][j-1];；这样双重循环就可获得结果。
leetcode63 最小路径和
从右下角到左上角，grid(i,j)=grid(i,j)+min(grid(i+1,j),grid(i,j+1))
leetcode96 不一样的二叉搜索树
典序的动态规划，G(n)=G(0)*G(n-1)+G(1)*G(n-2)+...+G(n-1)*G(0)，双重循环，不断计算G(0),G(1),G(2)...G(n-1),直到G(n)。
leetcode 乘积最大数组
leetcode221 最大正方形
动态规划递推思想为，定义一个矩阵，dp，与原矩阵规模相同，dp[i][j]表明以这个位置为右下角的正方形的面积，这样的话，上边和左边值为1的位置dp值为1，其他值为1的位置dp值为左、上、左上位置的值中最小的加1。
leetcode279 彻底平方数
动态规划递推思想为，f(x) = f(x-k)+1 k属于小于等于x的平方数的集合，递归的话时间复杂度较高，因此用动态规划，定义一个n+1长度的数组，dp[0]=0,fp[n]=dp[n-k]+1，这样就不用递归了。
类型12 全排列
leetcode78 子集
一开始res中只有[], [[]]，而后遍历arr,每次在原有子集的基础上，新增一个[[], [1]],以后[[],[1],[2],[1,2]]，而后[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]。
类型13 图
leetcode 207 课程表
学到了：用List> arr来作邻接矩阵，还不是稀疏的，挺好。用indegres表示入度数组，用queue表示入度为0的点(无限制学习的课程)。这道题本质上是判断图是否有环。
类型14 贪心算法
leetcode300 最长上升子序列
贪心算法+二分查找
最长上升子序列，最好能保持上升序列中数字最小，这是一种贪心思想，具体来作，就是遍历数组，若是数组中的数比先行序列中最大数字大，子序列长度加1，不然找到第一个比它小的数字(二分查找)，而后将这个数字的后一个数字替换掉。
时间复杂度nlogn
也能够用动态规划，dp[i]记录以i元素结尾位置上升子序列的值，时间复杂度n^2。
leetcode
类型15 其余(5)
12. 数值的整数次方
1)用位运算计算数字的正整数次幂 2)base=0时，指数不能为负 3)base小于0，求 倒数
19. 顺时针打印矩阵
关键点1：层数 2*level
关键点2：上边(无论啥样都有) 右边(最少两列) 下边(最少两行两列) 左边(最少三号两列)
31. 整数中1出现的次数
偷奸取巧，把数字转化为字符串，而后遍历
32. 丑数
记方法吧，记住了就会，记不住就不会
45. 扑克牌顺子(抽象建模能力)
关键点1：除0之外不能有其余数字出现两次
关键点2：max-min<=4，无论有几个0
leetcode146.LRU缓存机制
第一点是LRU这种数据结构的特征挺有意思的，第二点是用HashMap与双向链表构造这一数据结构的过程挺有意思的
leetcode208 实现Trie(前缀树)
前缀树也称字典树，在敏感词过滤和词语补全等方面颇有用，用result数组表示26个字母在当前节点是否出现，用isStirng表示当前节点是否某个单词的结尾单词。
469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
