力扣 练习2（十题）
Posted 冷血～多好
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了力扣 练习2（十题）相关的知识，希望对你有一定的参考价值。
目录
1. 删除有序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成
、
示例 1：输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2：输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示：
0 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列。
import java.util.ArrayList;
import java.util.List;
public class removeDuplicates {
public static void main(String[] args) {
int[] nums={1,1,2,5,6,7,7};
int [] n2=removeDuplicates(nums);
for(int n:n2){
System.out.println(n);
}
}
public static int[] removeDuplicates(int[] nums) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < nums.length; i++) {
if (i == 0) {
list.add(nums[0]);
}
if(i>=1){
if (list.get(list.size()-1) != nums[i]) {
list.add(nums[i]);
}
}
}
for(int i=0;i<list.size();i++){
nums[i]=list.get(i);
}
for(int i=list.size();i<nums.length;i++){
nums[i]=0;
}
return nums;
}
}2. 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100
class Solution {
public int removeElement(int[] nums, int val) {
int n=0;
List<Integer> list = new ArrayList<>();
for (int i = 0; i < nums.length; i++) {
if (val != nums[i]) {
list.add(nums[i]);
n++;
}
}
for(int i=0;i<list.size();i++){
nums[i]=list.get(i);
}
return n;
}
}
3. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:输入: nums = [1,3,5,6], target = 7
输出: 4
示例 4:输入: nums = [1,3,5,6], target = 0
输出: 0
示例 5:输入: nums = [1], target = 0
输出: 0
提示:
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为无重复元素的升序排列数组
-104 <= target <= 104
class Solution {
public int searchInsert(int[] nums, int target) {
int n=-1;
for(int i=0;i<nums.length;i++){
if(nums[i]==target){
n=i;
break;
}
}
if(n<0) {
for (int i = nums.length - 1; i >= 0; i--) {
if (target > nums[i]) {
n = i+1;
break;
} else {
n = 0;
}
}
}
return n;
}
}4.实现 strStr()
实现 strStr() 函数。
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
示例 1：
输入：haystack = "hello", needle = "ll"
输出：2
示例 2：输入：haystack = "aaaaa", needle = "bba"
输出：-1
示例 3：输入：haystack = "", needle = ""
输出：0
提示：
0 <= haystack.length, needle.length <= 5 * 104
haystack 和 needle 仅由小写英文字符组成
class Solution {
public int strStr(String haystack, String needle) {
return haystack.indexOf(needle);
}
}5.(6)Z字形变换
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：
P A H N
A P L S I I G
Y I R
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
请你实现这个将字符串进行指定行数变换的函数：
示例 1：
输入：s = "PAYPALISHIRING", numRows = 3
输出："PAHNAPLSIIGYIR"
示例 2：
输入：s = "PAYPALISHIRING", numRows = 4
输出："PINALSIGYAHRPI"
解释：
P I N
A L S I G
Y A H R
P I
示例 3：输入：s = "A", numRows = 1
输出："A"
提示：
1 <= s.length <= 1000
s 由英文字母（小写和大写）、',' 和 '.' 组成
1 <= numRows <= 1000
class Solution {
public String convert(String s, int numRows) {
if(s.length()<=numRows||numRows<=1){
return s;
}
String convert="";
int conums= column(s,numRows);
Character arrays[][]=new Character[numRows][conums];
int n=0;
int k=0;
for(int j=0;j<conums;j++){
for (int i = 0; i < numRows; i++) {
if(k>=s.length()){
break;
}
if(n==0||n==numRows-1){
arrays[i][j]=s.charAt(k);
k++;
if(n==numRows-1&&i==numRows-1){
n=0;
}
}
else {
arrays[numRows-n-1][j] = s.charAt(k);
k++;
break;
}
}
n++;
}
for(int i=0;i<numRows;i++){
for(int j=0;j<conums;j++){
if(arrays[i][j]!=null) {
convert += arrays[i][j];
}
}
}
return convert;
}
public int column(String s, int numRows){
int cycle=s.length()/(numRows+numRows-2);
if(cycle==0)
return 1+s.length()%numRows;
int remainder=s.length()%(numRows+numRows-2);
int remainder2=0;
if(remainder>0){
if(remainder<numRows){
remainder2=1;
}
else {
remainder2=remainder%numRows+1;
}
}
return (numRows-1)*cycle+remainder2;
}
}
6 .(19) 删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
示例 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) {
int size=size(head);
ListNode listNode=new ListNode();
listNode=head;
if(size==1&&n==1){
return null;
}
else if(n==size){
return head.next;
}
else if(n==1){
for(int i=0;i<size;i++){
if(i==size-2){
head.next=null;
break;
}
head = head.next;
}
}
else {
for(int i=1;i<size;i++){
if(i==size-n){
head.next=head.next.next;
break;
}
head = head.next;
}
}
return listNode;
}
public int size(ListNode head){
int n=1;
while (true){
if(head.next==null){
break;
}
head= head.next;
n++;
}
return n;
}
}7.(23) 合并K个升序链表
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：输入：lists = []
输出：[]
示例 3：输入：lists = [[]]
输出：[]
提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
/**
* 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 mergeKLists(ListNode[] lists) {
ListNode listNode=null;
for(int i=0;i<lists.length;i++){
listNode=mergeTwoKLists(listNode,lists[i]);
}
return listNode;
}
public ListNode mergeTwoKLists(ListNode list1,ListNode list2) {
if(list1==null||list2==null){
return list1!=null? list1:list2;
}
ListNode listNode=new ListNode();
ListNode head=listNode;
while (list1!=null&&list2!=null){
if(list1.val<list2.val){
listNode.next=list1;
list1=list1.next;
}
else {
listNode.next=list2;
list2=list2.next;
}
listNode=listNode.next;
}
listNode.next=(list1!=null?list1:list2);
return head.next;
}
}8.(25) K 个一组翻转链表
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
进阶：
你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例 3：
输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：输入：head = [1], k = 1
输出：[1]
提示：列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= 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 List<Integer> list2=new ArrayList<>();
public ListNode reverseKGroup(ListNode head, int k) {
int size=size(head);
if(size==1&&k==1){
return head;
}
List<Integer> list=new ArrayList<>();
ListNode listNode=head;
ListNode listNode2=head;
int n=0;
for(int i=0;i<size;i++){
if(i==0) {
list.add(head.val);
head=head.next;
}
else {
list.add(head.val);
head=head.next;
}
n++;
if(n==k){
addlist(list);
list.clear();
n=0;
}
if(i==size-1&&n<k){
addlist2(list);
}
}
// System.out.println("ddd"+list2.size());
for(int i=0;i<size;i++){
if(i==0) {
listNode.val=list2.get(i);
listNode= listNode.next;
}
else {
listNode.val=list2.get(i);
listNode= listNode.next;
}
}
return listNode2;
}
public static int size(ListNode head){
int n=1;
while (true){
if(head.next==null){
break;
}
head= head.next;
n++;
}
return n;
}
public void addlist(List<Integer> list){
for(int i=list.size()-1;i>=0;i--){
list2.add(list.get(i));
}
}
public void addlist2(List<Integer> list){
for(int i=0;i<list.size();i++){
list2.add(list.get(i));
}
}
}9.(58)最后一个单词的长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
示例 1：
输入：s = "Hello World"
输出：5
示例 2：输入：s = " fly me to the moon "
输出：4
示例 3：输入：s = "luffy is still joyboy"
输出：6
提示：
1 <= s.length <= 104
s 仅有英文字母和空格 ' ' 组成
s 中至少存在一个单词
class Solution {
public int lengthOfLastWord(String s) {
String result="";
boolean b=false;
for(int i=s.length()-1;i>=0;i--){
if(s.charAt(i)!=' '){
result+=s.charAt(i);
b=true;
}
if(s.charAt(i)==' '&&b){
break;
}
}
return result.length();
}
}
10.(66) 加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
示例 2：输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
示例 3：输入：digits = [0]
输出：[1]
提示：
1 <= digits.length <= 100
0 <= digits[i] <= 9
class Solution {
public int[] plusOne(int[] digits) {
if(digits.length<2){
if(digits[0]+1>9){
int digits2[]={1,0};
return digits2;
}
else {
digits[0]=digits[0]+1;
return digits;
}
}
else {
if(digits[digits.length-1]+1<=9){
digits[digits.length-1]=digits[digits.length-1]+1;
return digits;
}
else {
for(int i=digits.length-1;i>=0;i--){
if(i>0) {
if (digits[i] + 1 > 9) {
digits[i] = 0;
digits[i - 1] = digits[i - 1] + 1;
if( digits[i - 1]<=9){
break;
}
}
}
}
if(digits[0]>9){
int [] digits2=new int[digits.length+1];
for(int j=digits.length;j>0;j--){
digits2[j]=0;
}
digits2[0]=1;
return digits2;
}
else {
return digits;
}
}
}
}
}以上是关于力扣 练习2（十题）的主要内容，如果未能解决你的问题，请参考以下文章