文章目录
- @[toc]
- Hash相关
- [1. 两数之和](https://leetcode-cn.com/problems/two-sum/)
- [387. 字符串中的第一个唯一字符](https://leetcode-cn.com/problems/first-unique-character-in-a-string/)
- 链表操作
- [2. 两数相加](https://leetcode-cn.com/problems/add-two-numbers/)
- [19. 删除链表的倒数第 N 个结点](https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)
- q25_k个一组翻转链表
- [61. 旋转链表](https://leetcode-cn.com/problems/rotate-list/)
- q138_复制带随机指针的链表
- [206. 反转链表](https://leetcode-cn.com/problems/reverse-linked-list/)
- 双指针遍历/滑动窗口
- 快慢指针遍历
- 区间合并
- 字符串操作
- 数字操作
- 数组操作
- [54. 螺旋矩阵](https://leetcode-cn.com/problems/spiral-matrix/)
- [581. 最短无序连续子数组](https://leetcode-cn.com/problems/shortest-unsorted-continuous-subarray/)
- 栈相关
- 堆相关
- 递归
- 分治法/二分法
- 动态规划
- 回溯法
- 字典树（前缀树）
- 树的遍历
- 二叉搜索树相关
Hash相关
1. 两数之和
难度简单11915收藏分享切换为英文接收动态反馈
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
提示：
- 2 <= nums.length <= 104
- -109 <= nums[i] <= 109
- -109 <= target <= 109
- 只会存在一个有效答案
**进阶：**你可以想出一个时间复杂度小于 O(n2) 的算法吗？
class Solution {
// 暴力
public int[] twoSum(int[] nums, int target) {
int[] res = new int[2];
int len=nums.length;
for(int i=0;i<=len-1;i++){
for(int j=i+1;j<=len-1;j++){
if(nums[i]+nums[j]==target){
res[0]=i;
res[1]=j;
return res;
}
}
}
return res;
}
}
/**
* 一遍hash 时间o(n) 空间o(n)
*/
import java.util.Map;
import java.util.HashMap;
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map =new HashMap<Integer,Integer>();
int len=nums.length;
for(int i=0;i<=len-1;i++){
if(map.containsKey(target-nums[i])){
return new int[]{map.get(target-nums[i]),i};
}
map.put(nums[i],i);
}
return null;
}
}387. 字符串中的第一个唯一字符
难度简单429收藏分享切换为英文接收动态反馈
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
示例：
s = "leetcode"
返回 0
s = "loveleetcode"
返回 2
**提示：**你可以假定该字符串只包含小写字母。
import java.util.*;
class Solution {
public int firstUniqChar(String s) {
char[] chars = s.toCharArray();
Map<Character,Integer> map = new HashMap<Character,Integer>();
// 重复的字符顶为-1；
for(int i=0;i<=s.length()-1;i++){
if(map.containsKey(chars[i])){
map.put(chars[i],-1);
}else{
map.put(chars[i],i);
}
}
// 然后再便利一遍如果是第一个出现的不为-1 的我们就返回
for(int i=0;i<=s.length()-1;i++){
int value = map.get(chars[i]);
if(value!=-1){
return value;
}
}
return -1;
}
}
链表操作
2. 两数相加
难度中等6636
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
- 每个链表中的节点数在范围 [1, 100] 内
- 0 <= Node.val <= 9
- 题目数据保证列表表示的数字不含前导零
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
/**
* 两次遍历
* 第一次遍历：两个链表对应每个节点分别取和，若含有空节点则空节点取0，产生一个新链表。
* 第二次遍历：对取完和的新链表遍历，判断当前的val是否大于等于10，大于或等于则其自身-10其next加1，若next为空则新建0节点。
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode res=new ListNode(l1.val+l2.val);
ListNode link1=l1.next;
ListNode link2=l2.next;
ListNode p=res;
while(link2!=null||link1!=null){
int a=0;
int b=0;
if(link1!=null){
a=link1.val;
}
if(link2!=null){
b=link2.val;
}
int t=a+b;
p.next=new ListNode(t);
p=p.next;
if(link1!=null){
link1=link1.next;
}
if(link2!=null){
link2=link2.next;
}
}
p=res;
while(p!=null){
if(p.val>=10){
p.val=p.val-10;
if(p.next==null){
p.next=new ListNode(0);
}
p=p.next;
p.val=p.val+1;
}
else{
p=p.next;
}
}
return res;
}
}
19. 删除链表的倒数第 N 个结点
难度中等1525
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
**进阶：**你能尝试使用一趟扫描实现吗？
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
- 链表中结点的数目为 sz
- 1 <= sz <= 30
- 0 <= Node.val <= 100
- 1 <= n <= sz
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode res = new ListNode(0);
res.next=head;
ListNode fast=res;
ListNode slow=res;
for(int i=1;i<=n+1;i++){
fast=fast.next;
}
while(fast!=null){
fast=fast.next;
slow=slow.next;
}
slow.next=slow.next.next;
return res.next;
}
}
q25_k个一组翻转链表
61. 旋转链表
难度中等615
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]
示例 2：
输入：head = [0,1,2], k = 4
输出：[2,0,1]
提示：
- 链表中节点的数目在范围 [0, 500] 内
- -100 <= Node.val <= 100
- 0 <= k <= 2 * 109
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode rotateRight(ListNode head, int k) {
if(head==null|| k==0){
return head;
}
int len=1;
ListNode tail=head;
ListNode pre=head;
ListNode res=head;
while(tail.next!=null){
tail=tail.next;
len++;
}
tail.next=head;
//循环链表移动次数，即将res指针移动到末尾的k%len处
int loop=len-(k%len);
System.out.println(k);
for(int i=0;i<loop;i++){
pre=res;
res=res.next;
}
pre.next=null;
return res;
}
}
q138_复制带随机指针的链表
206. 反转链表
难度简单1921
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
- 链表中节点的数目范围是 [0, 5000]
- -5000 <= Node.val <= 5000
**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
//头插法
ListNode p=new ListNode(0);
p.next=null;
ListNode temp=head;
while(head!=null){
temp=head.next;
head.next=p.next;
p.next=head;
head=temp;
}
return p.next;
}
}
双指针遍历/滑动窗口
- q3_无重复字符的最长子串
- q11_盛最多水的容器
- q15_三数之和
- q16_最接近的三数之和
- q26_删除排序数组中的重复项
- q42_接雨水
- q121_买卖股票的最佳时机
- q209_长度最小的子数组
快慢指针遍历
- q141_环形链表
- q202_快乐数
- q876_链表的中间结点
区间合并
- q56_合并区间
字符串操作
- q6_Z字形变换
- q14_最长公共前缀
- q763_划分字母区间
数字操作
- q7_整数反转
- q8_字符串转换整数
- q9_回文数
- q43_字符串相乘
- q172_阶乘后的零
- q258_各位相加
数组操作
54. 螺旋矩阵
难度中等859收藏分享切换为英文接收动态反馈
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
提示：
- m == matrix.length
- n == matrix[i].length
- 1 <= m, n <= 10
- -100 <= matrix[i][j] <= 100
- q73_矩阵置零
- q78_子集
- q384_打乱数组
581. 最短无序连续子数组
难度中等693
给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。
请你找出符合题意的 最短 子数组，并输出它的长度。
示例 1：
输入：nums = [2,6,4,8,10,9,15]
输出：5
解释：你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。
示例 2：
输入：nums = [1,2,3,4]
输出：0
示例 3：
输入：nums = [1]
输出：0
提示：
- 1 <= nums.length <= 104
- -105 <= nums[i] <= 105
class Solution {
public int findUnsortedSubarray(int[] nums) {
if (nums == null || nums.length < 1) {
return 0;
}
int[] cloneNums = nums.clone();
Arrays.sort(nums);
int begin = Integer.MAX_VALUE;
int end = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] != cloneNums[i]) {
begin = Math.min(begin, i);
end = Math.max(end, i);
}
}
return Math.max(end - begin + 1, 0);
}
}- q945_使数组唯一的最小增量
栈相关
- q20_有效的括号
- q32_最长有效括号
- q155_最小栈
- q224_基本计算器
- q232_用栈实现队列
- q316_去除重复字母
堆相关
- q215_数组中的第K个最大元素
- q347_前K个高频元素
递归
- q21_合并两个有序链表
- q101_对称二叉树
- q104_二叉树的最大深度
- q226_翻转二叉树
- q236_二叉树的最近公共祖先
- q1325_删除给定值的叶子节点
分治法/二分法
- q23_合并K个排序链表
- q33_搜索旋转排序数组
- q34_在排序数组中查找元素的第一个和最后一个位置
动态规划
- q5_最长回文子串
- q53_最大子序和
- q62_不同路径
- q64_最小路径和
- q70_爬楼梯
- q118_杨辉三角
- q300_最长上升子序列
- q1143_最长公共子序列
- q1277_统计全为1的正方形子矩阵
回溯法
- q10_正则表达式匹配
- q22_括号生成
- q40_组合总和2
- q46_全排列
字典树（前缀树）
- q648_单词替换
树的遍历
- q94_二叉树的中序遍历
- q102_二叉树的层次遍历
- q110_平衡二叉树
- q144_二叉树的前序遍历
- q145_二叉树的后序遍历
二叉搜索树相关
- q98_验证二叉搜索树
- q450_删除二叉搜索树中的节点
- q701_二叉搜索树中的插入操作
