详见原文，转载自：https://www.cnblogs.com/expiator/p/10226647.html
刷完题后，看一下其他人的solution，受益匪浅。
可以按不同的topic刷题，比如数组、字符串、集合、链表等等。先做十道数组的题，接着再做十道链表的题。
刷题，最主要的是，学习思路。
多刷几遍。挑面试常考的重点刷。
面试常考的LeetCode题目参考： https://blog.csdn.net/weixin_38118016/article/details/90761111
可以采用兔系刷题，就是直接看答案，因为很多算法如果事先不知道是很难靠自己想出来的，知道了思路，刷第二遍的时候就不用看答案了。
龟系刷题，就是自己慢慢磨，花费时间多些，难得也更难忘。甚至还可以一题多解。
个人习惯用java。当然，练习新的语言时，比如学python时也可以刷题练手。
基础
Char
1.字符Char类型是基本类型的，比较时直接用== 。
2.字符'a'到'z'之间的距离可以直接通过('a'-'z')获得。
3.判断字符是否为字母：
char c='c';
boolean isLetter=Character.isLetter(c);
数组
1.双指针(Two Pointers)。第一个下标i从前往后迭代，第二个下标j从后往前迭代。不断循环，最后i和j会相等。。
递归
1.使用递归的条件：子问题需与原问题为同样的事，且规模更小；程序有停止条件。
2.递归三要素： a.设置终止条件。b.设置返回值。c.在运行的过程中调用下一级/上一级的参数。
3.递归的本质，就是栈。
递归的写法如下：
假设有一些元素x1,x2,x3...元素的计算结果，比如元素x2的计算结果由元素x1的计算结果等等决定。
public 返回类型 function(参数类型 元素x1 ) {
//写出x1相关的计算逻辑，以及递归程序终止的条件
//调用方法本身，参数为"下一个元素x2"、"下下个元素x3"等等
}
示例如下：
//利用递归计算阶乘 ：n*(n-1)*...*1
public int recursion(int num){
//忽略其他的异常参数校验，比如负数等等
//先写第一个元素的计算结果，以及递归程序终止的条件
if(num==1){
return 1;
}
//调用方法本身，参数为其他的元素
int sum=1;
sum=num * recursion(num-1);//运用递归计算
return sum;
}
递归典型问题： 梵塔问题（汉诺塔问题）
字符串
1.字符串的遍历，需要先使用toCharArray()转化为字符数组。
示例题目：计算某个字符串里面A字符的次数。
public int countChar(String word) {
if(word==null) {
return 0;
}
int count=0;
for (char c : word.toCharArray()) {
if (c == 'A') {
count++;
}
}
return count;
}
Set
1.HashSet无序不重复，可以用来过滤筛选掉List或数组中的重复数据。
Set的size和原来集合（可以是list，还可以是map等集合）的size相同，说明没有重复数据。也可以用contains()判断。
示例如下：
List<String> list=new ArrayList<>();
list.add("123");
list.add("456");
list.add("123");
//将list的数据放进set里面，进行去重。
Set<String> set = new HashSet<>(list);
for (String s : set) {
//...
}
//list的size()和set的size()相等，说明没有重复数据。
if( list.size() == set.size()){
}
Map
1.Map可以用于处理两个变量的关系。一个变量作为键，另一个变量作为值。
经常可以用来统计数量。如下：
public static boolean uniqueOccurrences(int[] arr) {
Map<Integer, Integer> map = new HashMap<>();
for (int num : arr) {
//通过map来统计出现的次数
//数组值作为key，对应的map中的value值进行加一操作。如果不存在，就设为1.
map.put(num, map.getOrDefault(num, 0) + 1);
}
//如果set集合的数量和map集合的数量是一样的，说明没有重复的值。
Set<Integer> set = new HashSet<>(map.values());
return map.size() == set.size();
}
链表
https://www.cnblogs.com/expiator/p/10803779.html
队列
栈
先进后出。
push入栈，pop出栈，peek查看但不移除.top查看栈顶
public void stackDemo(){
Stack<String> stack=new Stack<String>();
stack.push("a");
stack.push("b");
stack.push("c");
while(!stack.isEmpty()) {
System.out.println(stack.pop());
}
}
树
- 树的数据结构如下：
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
- 树节点的初始化：
int val=1;
TreeNode node = new TreeNode(val);
- 节点为node，求左右子树：
TreeNode right =node.right;
TreeNode left=node.left;
- 树经常会用到递归。
比如N叉树的前序遍历。
class LeetCode589{
//list设置为成员变量，如果是方法内变量,无法一直添加元素
private List<Integer> list = new LinkedList<>();
public List<Integer> preorder(Node root) {
if(root==null) {
return list;
}
list.add(root.val);
for (Node node : root.children) {
preorder(node);
}
return list;
}
}
- 树还可以用迭代法。利用栈的先进后出解题。
N叉树的前序遍历。
class Solution {
public List<Integer> preorder(Node root) {
List<Integer> list = new ArrayList<>();
if (root == null) return list;
//将根节点数据添加到栈中
Stack<Node> stack = new Stack<>();
stack.add(root);
while (!stack.empty()) {
//栈顶的数据，出栈
root = stack.pop();
//在list中添加栈顶数据
list.add(root.val);
//当前节点的所有子节点，入栈
for (int i = root.children.size() - 1; i >= 0; i--)
stack.add(root.children.get(i));
}
return list;
}
}
DFS(深度优先搜索算法)
DFS的实现方式相比于BFS应该说大同小异，只是把queue换成了stack而已，stack具有后进先出LIFO(Last Input First Output)的特性，DFS的操作步骤如下：
1、把起始点放入stack；
2、重复下述3步骤，直到stack为空为止：
从stack中访问栈顶的点；
找出与此点邻接的且尚未遍历的点，进行标记，然后全部放入stack中；
如果此点没有尚未遍历的邻接点，则将此点从stack中弹出。
BFS(广度优先搜索算法)。
示例：求二叉树的最大深度。
public class LeetCode104BFS {
public int maxDepth(TreeNode root) {
if (root == null){
return 0;
}
int depth = 0;
Queue<TreeNode> nodes = new LinkedList<>();
//队列使用offer和poll不会抛异常
nodes.offer(root);
while (!nodes.isEmpty()) {
//size就相当于每一层的数量，也就是宽度
int size = nodes.size();
//遍历一次，深度就加一
depth++;
//遍历队列中的数据
while (size-- > 0) {
//取出队列中的树节点
TreeNode node = nodes.poll();
//将当前节点的左右子树，放入队列中。
if (node!=null && node.left != null){
nodes.offer(node.left);
}
if (node!=null && node.right != null){
nodes.offer(node.right);
}
}
}
return depth;
}
}
哈希表
- 哈希表是根据关键码值（Key Value）而直接进行访问的数据结构。它通过把关键码值映射到哈希表中的一个位置来访问记录，以加快查找的速度。这个映射函数就做散列函数，存放记录的数组叫做散列表。
- 哈希表，相当于数组加链表。
- 可以多看一下HashMap的源码，HashMap就是用哈希表实现的。
哈希数组
- 创建一个哈希数组，数组下标记录各个数字/字符，数组的值为数字/字符出现的次数。
//将字符串p中，各个字符出现的次数记录下来。chars[]数组用于计数。
//比如p="abc"，那么chars为{1,1,1,0,0....0}
//也可以说，在哈希数组chars中标记字符串p中出现的字符状况。
int[] chars = new int[26];
for (Character c : p.toCharArray()){
chars[c-'a']++;
}
示例如下：
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。比如s = "anagram", t = "nagaram"。
public class LeetCode242 {
public boolean isAnagram(String s, String t) {
if (s == null && t == null) {
return true;
}else if (s == null ) {
return false;
}
int[] counts = new int[26];
//先用哈希数组，将26个字符出现的次数都记下来。
//然后再遍历字符串t，将每种字符出现的次数逐次减一
for (int i = 0; i < s.length(); i++) {
counts[s.charAt(i) - 'a']++;
counts[t.charAt(i) - 'a']--;
}
//如果两个字符串是异位字母，那么遍历过后数组counts的每一个元素都是0.
for (int num : counts) {
if (num != 0) {
return false;
}
}
return true;
}
}
动态规划
“动态规划”用于多阶段最优解问题的求解。
关键的思想在「自底向上」和「空间换时间」。
动态规划的几个步骤：
1、设定状态。
二维 dp 问题，可以使用二维数组 dp[i][j]，第一维的下标i可以表示A事物的状态，第二维的下标j可以表示B事物的状态。
2、思考状态转移方程。
找规律，找出 dp[i][j]是怎么由dp[i-1][j]、 dp[i-1][j-1] 推导得到的
3、考虑初始值。
也就是 dp[0][0] 、 dp[0][1] 之类的初始值。
4、考虑输出。
求出 dp[len - 1][j] (也可能是其他的如dp[len - 1][j]) 的值。
动态规划入门题：LeetCode121，LeetCode122
参考资料： https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/solution/bao-li-mei-ju-dong-tai-gui-hua-chai-fen-si-xiang-b/
查找
排序
堆
图
持续刷题中。
待补充。
