关于作者：
大家好，我是Leetcode 2020--2022,连续3年金牌获得者，和亚洲区域赛铜牌获得者，
先后在字节和大疆从事技术研发，现在是阿里达摩院的扫地僧，面试专家，CSDN博客专家。
对算法一定的见解，是一个刷题10年的算法爱好者 ，利用工作之余刷leetcode。成为leetcode官方答案贡献者之一。
7天课程目录，免费！踢馆抖音算法 （7天刷新法）
1. 第一天：一个视频教会你时间复杂度和空间复杂度 0912
2. 第二天：一个视频教会你必考的8种数据结构（视频，图文并茂） 0913
3. 第三天：一个视频教会你常用的8中解题方法和算法模版（简直不要太简单） 0912
4. 第四天：一个视频教会你 6大高频考点 常用操作技巧，常用的字符，数组，类型（独家） 0911
5. 第五天： Top10，最高频题，99%命中面试题(字节，快手，shapee，大疆, 华为，蔚来 ) ok
6. 第六天： Hot 20 , 大厂面试算法真题，95%命中(精选: 京东,美团,小米,拼多多,网易)（非算法工程师误入） 0910
7. 第七天： Top5, 经典热题5，90%命中面试题（剑指offer）
题库来源: Top100&&Top50 出现频率五颗星
1. 最高频题，995%命中题(精选: 京东,美团,小米,拼多多,网易)
2. 作为大厂面试管，经常出题，同时从海量题库中找出9题。
Top1: 27:移除元素 双指针
Top2: 24: 链表交换 链表节点
Top3: 77:组合 DFS和BFS的区别
Top4: 90: 子集2 回溯
Top5: 268:丢失的数字 哈希表
Top6: 53. 最大子数组和 分治+数组
Top7: 57:插入区间 排序法
Top8: 209: 长度最小的子数组 滑动窗口
Top9: 35:搜索插入的位置 二分法
总结:8种排序+8种数据结构+8种算法+6大类型考题
Top1: 27:移除元素 双指针
public class Leetcode27 {
public int removeElement(int[] nums, int val) {
if (nums ==null || nums.length ==0) {
return 0;
}
int l =0;
int r = nums.length -1;
while (l < r) {
while (l < r && nums[l] != val) {
l++;
}
while (l < r && nums[r] == val) {
r--;
}
int temp = nums[l];
nums[l] = nums[r];
nums[r] = temp;
}
return nums[l] == val ? l : l +1;
}
}
Top2: 24: 链表交换 链表节点
public class Leetcode24 {
public ListNodeswapPairs(ListNode head) {
if (head ==null || head.next ==null) {
return head;
}
ListNode newHead = head.next;
head.next = swapPairs(newHead.next);
newHead.next = head;
return newHead;
}
}
Top3: 77:组合 DFS和BFS的区别
Top4: 90: 子集2 回溯
private List<List<Integer>> ans = new ArrayList<>();
public List<List<Integer>> combine(int n, int k) {
getCombine(n, k, 1, new ArrayList<>());
return ans;
}
public void getCombine(int n, int k, int start, List<Integer> list) {
if(k == 0) {
ans.add(new ArrayList<>(list));
return;
}
for(int i = start;i <= n - k + 1;i++) {
list.add(i);
getCombine(n, k - 1, i+1, list);
list.remove(list.size() - 1);
}
}
Top5: 268:丢失的数字 哈希表
public class Leetcode268 {
/***
*示例 1：
*
* 输入：nums = [3,0,1]
* 输出：2
* 解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。
* @param nums
* @return
*/
public int missingNumber(int[] nums) {
HashSet set =new HashSet<>(); // 不会重复
for (int num : nums) {// 存放在hashset中
set.add(num);
}
for (int i =0; i < nums.length; i++) {
if (!set.contains(i)) {
return i;
}
}
return nums.length;
}
}
Top6: 53. 最大子数组和 分治+数组
public class Leetcode53 {
/***
* 输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
* 输出：6
* 解释：连续子数组 [4,-1,2,1] 的和最大，为 6
* @param nums
* @return
*/
public int maxSubArray(int[] nums) {
return getMaxDividing(nums, 0, nums.length -1);
}
private int getMaxDividing(int[] nums, int start, int end) {
if (start == end) {
return nums[start];
}
// 得到中间的索引
int middle = start + (end - start) /2;
int leftSum =0;
int rightSum =0;
int crossSum =0;
// 得到最左边的最大值
leftSum = getMaxDividing(nums, start, middle);
// 得到右边的最大值
rightSum = getMaxDividing(nums, middle +1, end);// 起始值注意+1
crossSum = getCrossSum(nums, start, end);
int max = Math.max(leftSum, rightSum);
max = Math.max(max, crossSum);
return max;
}
private int getCrossSum(int[] nums, int start, int end) {
int middle = start + (end - start) /2;
int leftSum =0;
int leftMax =0;
for (int i = middle; i >0; i--) {
leftSum = leftSum + i;
if (leftSum > leftMax) {
leftMax = leftSum;
}
}
int rightSum =0;
int rightMax =0;
for (int i = middle +1; i < end; i++) {
rightSum = rightSum + i;
if (rightSum > rightMax) {
rightMax = rightSum;
}
}
return leftMax + rightMax;
}
}
Top7: 57:插入区间 排序法
public class Leetcode57 {
@RequiresApi(api = Build.VERSION_CODES.N)
public int[][]insert(int[][] intervals, int[] newInterval)throws Exception {
if (intervals.length ==0) {
return new int[][]{newInterval};
}
ArrayList result =new ArrayList<>();
ArrayList temp =new ArrayList<>();
for (int[] interval : intervals) {
temp.add(interval);
}
temp.add(newInterval);
temp.sort((a, b) -> a[0] - b[0]);
for (int[] interval : temp) {
int[] lastestResult = result.size() ==0 ?new int[]{-1, -1} : result.get(result.size() -1);
if (result.size() ==0 || lastestResult[1] < interval[0]) {
result.add(interval);
}else {
lastestResult[1] = Math.max(lastestResult[1], interval[1]);
}
}
return result.toArray(new int[result.size()][2]);
}
}
Top8: 209: 长度最小的子数组 滑动窗口
public class Leetcode209 {
public int minSubArrayLen(int target, int[] nums) {
if (nums ==null || nums.length ==0) {
return 0;
}
int size =1;
while (size <= nums.length) {
for (int i =0; i < nums.length - size +1; i++) {
int total =0;
for (int j = i; j < i + size; j++) {
total += nums[j];
}
if (total >= target) {
return size;
}
}
size++;
}
return 0;
}
}
Top9: 35:搜索插入的位置 二分法
public class Leetcode35 {
public int searchInsert(int[] nums, int target) {
if (nums ==null || nums.length ==0) {
return 0;
}
int left =0;
int right = nums.length -1;
while (left < right) {
int mid = left + (right - left) /2;
if (nums[mid] == target) {
return mid;
}else if (nums[mid] > target) {
right = mid;
}else {
left = mid +1;
}
}
return nums[left] < target ? left +1 : left;
}
}
网友评论