English edition
难度简单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;
}
}
难度简单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;
}
}
难度中等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;
}
}
难度中等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]
提示：
sz1 <= sz <= 300 <= Node.val <= 1001 <= 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(
