LeetCode解题思路

刷完题后，看一下其他人的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/

查找

排序

堆

图

持续刷题中。

待补充。

参考资料：

面试高频出现的 leetcode 算法题集