文章目录
-
-
- 力1. 两数之和
- 力 2. 两数相加
- 力 3. 无重复字符的最长子串
- 力 5. 最长回文子串
- 力7. 整数反转
- 力9. 回文数
- 力14. 最长公共前缀
- 力15. 三数之和
- 力16. 最接近的三数之和
- 力 18四数之和
- 力19. 删除链表的倒数第N个节点
- 力20. 有效的括号
- 力21. 合并两个有序链表
- 力22. 括号生成
- 力32 最长有效括号
- 力扣25 . K个一组翻转链表
力1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
class Solution {
public int[] twoSum(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (target == nums[i] + nums[j]) {
return new int[]{
i, j};
}
}
}
throw new IllegalArgumentException("没有两数之和");
}
}
力 2. 两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储
的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode head=new ListNode(0);
ListNode pre=head;
ListNode p1=l1, p2=l2;
int sum=0;
while (p1!=null||p2!=null){
if (p1!=null){
sum+=p1.val;
p1=p1.next;
}
if (p2!=null){
sum+=p2.val;
p2=p2.next;
}
pre.next=new ListNode(sum%10);
pre=pre.next;
sum=sum/10;
}
if (sum==1){
pre.next=new ListNode(1);
}
return head.next;
}
}
力 3. 无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
class Solution {
public int lengthOfLongestSubstring(String s) {
Set<Character> occ = new HashSet<Character>();
int n = s.length();
int rk = -1, ans = 0;
for (int i = 0; i < n; ++i) {
if (i != 0) {
occ.remove(s.charAt(i - 1));
}
while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {
occ.add(s.charAt(rk + 1));
++rk;
}
ans = Math.max(ans, rk - i + 1);
}
return ans;
}
}
力 5. 最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
public String longestPalindrome(String s) {
if (s.isEmpty()) {
return "";
}
int len = s.length();
boolean[][] dp = new boolean[len][len];
String ans = "";
int maxLen = 0;
for (int j = 0; j < s.length(); j++) {
for (int i = 0; i <= j; i++) {
dp[i][j] = s.charAt(i) == s.charAt(j)
&& ((j - i <= 2) || dp[i + 1][j - 1]);
if (dp[i][j]) {
if (j - i + 1 > maxLen) {
maxLen = j - i + 1;
ans = s.substring(i, j + 1);
}
}
}
}
return ans;
}
}
力7. 整数反转
public int reverse(int x) {
long res=0;
while (x!=0){
res=res*10+x%10;
x/=10;
if(res>Integer.MAX_VALUE||res<Integer.MIN_VALUE)return 0;
}
return (int) res;
}
力9. 回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
public class Solution {
public boolean isPalindrome(int x) {
boolean b = HuiWen(String.valueOf(x));
return b;
}
public boolean HuiWen(String s){
StringBuilder stringBuilder=new StringBuilder(s);
StringBuilder reverse = stringBuilder.reverse();
if (s.equals(reverse.toString())){
return true;
}
return false;
}
}
力14. 最长公共前缀
public class Solution {
public static void main(String[] args) {
String[] strs={
"dog","racecar","car"};
longestCommonPrefix(strs);
}
public static String longestCommonPrefix(String[] strs) {
if (strs==null||strs.length==0) return "";
String res = strs[0];
for (int i = 1; i <strs.length; i++) {
while (strs[i].indexOf(res)!=0){
res=res.substring(0,res.length()-1);
}
}
return res;
}
}
力15. 三数之和
public class Solution {
public List<List<Integer>> threeSum(int[] nums) {
if(nums.length==0||nums==null) return new ArrayList<>();
Arrays.sort(nums);
Set<List<Integer>> set =new HashSet<>();
for (int i = 0; i < nums.length; i++) {
int left=i+1,right=nums.length-1;
while (left<right){
if (nums[i]+nums[left]+nums[right]==0){
set.add(Arrays.asList(nums[i],nums[left],nums[right]));
left++;
right--;
}else if (nums[i]+nums[left]+nums[right]<0){
left++;
}else if (nums[i]+nums[left]+nums[right]>0){
right--;
}
}
}
List<List<Integer>> list=new ArrayList<>();
list.addAll(set);
return list;
}
}
力16. 最接近的三数之和
import java.util.Arrays;
public class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int res=nums[0]+nums[1]+nums[2];
for (int i = 0; i < nums.length; i++) {
int left=i+1;
int right=nums.length-1;
while (left<right){
if (Math.abs(nums[i]+nums[left]+nums[right]-target)< Math.abs(res-target)){
res=nums[i]+nums[left]+nums[right];
}else if (nums[i]+nums[left]+nums[right]>target){
right--;
}else if (nums[i]+nums[left]+nums[right]<target){
left++;
}else {
return res;
}
}
}
return res;
}
}
力 18四数之和
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
public class Solution {
public List<List<Integer>> fourSum(int[] nums, int target){
if(nums==null||nums.length<4) return new ArrayList<>();
Arrays.sort(nums);
HashSet<List<Integer>> set = new HashSet<>();
int length=nums.length;
for (int i = 0; i < length; i++) {
for (int j = i+1; j < length; j++) {
int left=j+1;
int right=nums.length-1;
while (left<right){
if (nums[i]+nums[j]+nums[left]+nums[right]==target){
set.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
left++;
right--;
}else if (nums[i]+nums[j]+nums[left]+nums[right]>target){
right--;
}else {
left++;
}
}
}
}
List<List<Integer>> list=new ArrayList<>();
list.addAll(set);
return list;
}
}
力19. 删除链表的倒数第N个节点
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode start =new ListNode(0);
ListNode slow=start;
ListNode fast=start;
start.next=head;
for (int i = 0; i < n; i++) {
fast=fast.next;
}
while (fast.next!=null){
fast=fast.next;
slow=slow.next;
}
slow.next=slow.next.next;
return start.next;
}
}
力20. 有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: "()"
输出: true
class Solution {
public boolean isValid(String s) {
if(s==null||s.length()==0) return true;
Stack<Character> stack = new Stack<>();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i)=='('){
stack.push(')');
}else if (s.charAt(i)=='{'){
stack.push('}');
}else if (s.charAt(i)=='['){
stack.push(']');
}else {
if (stack.isEmpty()||stack.pop()!=s.charAt(i))return false;
}
}
return stack.isEmpty();
}
}
力21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
public class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dump=new ListNode(0);
ListNode cur=dump;
while (l1!=null&&l2!=null){
if (l1.val<l2.val){
cur.next=new ListNode(l1.val);
l1=l1.next;
}else {
cur.next=new ListNode(l2.val);
l2=l2.next;
}
cur=cur.next;
}
if (l1!=null){
cur.next=l1;
}else {
cur.next=l2;
}
return dump.next;
}
}
力22. 括号生成
public class Solution {
public List<String> generateParenthesis(int n) {
List<String> res =new ArrayList<>();
dfs("",n,n,res);
return res;
}
public void dfs(String curString,int left,int right,List<String>res){
if (left==0&&right==0){
res.add(curString);
return;
}
if (left>right) {
return;
}
if (left>0){
dfs(curString+"(",left-1,right,res);
}
if (right>0){
dfs(curString+")",left,right-1,res);
}
}
}
力32 最长有效括号
给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。
示例 1:
输入: "(()"
输出: 2
解释: 最长有效括号子串为 "()"
示例 2:
输入: ")()())"
输出: 4
解释: 最长有效括号子串为 "()()"
public int longestValidParentheses(String s) {
if(s==null||s.length()==0) return 0;
int start=0,max=0;
Stack<Integer> stack = new Stack<>();
for (int index = 0; index < s.length(); index++) {
if (s.charAt(index)=='('){
stack.push(index);
}else {
if (stack.empty()){
start=index+1;
}else {
stack.pop();
if (stack.empty()){
max=Math.max(max,index-start+1);
}else {
max=Math.max(max,index-stack.peek());
}
}
}
}
return max;
}
力扣25 . K个一组翻转链表
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
示例：
给你这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
ListNode next = head;
int i = 0;
for(i = 0; i < k; i++){
if(next == null)
break;
next = next.next;
}
if(i < k)
return head;
ListNode cur = head.next;
ListNode pre = head;
ListNode temp;
head.next = reverseKGroup(next, k);
while(cur != next){
temp = cur.next;
cur.next = pre;
pre = cur;
cur = temp;
}
return pre;
}
}
