力扣 练习2（十题）

最新推荐文章于 2023-05-07 09:17:47 发布
最新推荐文章于 2023-05-07 09:17:47 发布
阅读量109 收藏
点赞数
分类专栏： 力扣 文章标签： 数据结构 html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44716544/article/details/120399396
版权

目录

1. 删除有序数组中的重复项

2. 移除元素

 3. 搜索插入位置

  4.实现 strStr()

5.(6)Z字形变换

 6 .(19) 删除链表的倒数第 N 个结点

7.(23) 合并K个升序链表

8.(25) K 个一组翻转链表

9.(58)最后一个单词的长度

10.(66) 加一

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;
                }


            }

        }



    }
}

冷血～多好
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题篇 21题合并两个排序的链表 java C++版本
weixin_45806131的博客
09-06 212
题目放一下： 思路分析： 举例分析一波： l1和l2是要合并的两个链表，m是最后组合而成的链表 上代码： 首先是C++的： 使用链表： class Solution { public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode dummy(0); ListNode* tail = &dummy; while(l1 && l2) {
LeetCode算法入门之 递归 / 回溯——21. 合并两个有序链表
qq_49182770的博客
02-11 320
将两个升序链表合并为一个新的 升序 链表并返回。 新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 思路 如果 l1 或者 l2 一开始就是空链表 ， 那么我们只需要返回非空链表。 否则，我们要判断 l1 和 l2 哪一个链表的头节点的值更小， 然后递归地
LeetCode--合并两个有序链表
Yshasd的博客
12-02 721
本题是LeetCode初级算法中一道关于链表的题，其中的方法包括但不限于递归、迭代等等，后续在寒假可能会使用不同的语言Java、Python、javascript等语言去实现这些算法。
【小Y学算法】⚡️每日LeetCode打卡⚡️——12.合并两个有序链表
努力前行，总会成为自己心中的那道光
08-17 9725
算法题打卡：合并两个有序链表。没有特别幸运，那么请先特别努力，别因为懒惰而失败，还矫情地将原因归于自己倒霉。所以说，树倒了，没有一片雪花是无辜的
leetcode 刷题笔记（21，58）
smallworldxyl的博客
10-07 110
题目：21 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 c++ 非递归 class Solution { public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if(l1==nullptr) return l2; if(l2==nullptr) return l1
leetcode下载-leetcode:力扣的练习题
06-29
是不是有许多小伙伴在刷力扣的时候感觉无从下手？从头按顺序开始刷的童鞋们可能会比较有感触，为什么才第四题就感觉很难了?没关系，本文将对力扣的 1-700 题中不需要会员的数据结构与算法题目(数据库与 shell 除外)...
leetcode题库-LeetCode:力扣题库练习
06-29
leetcode题库 LeetCode 力扣题库练习 中文网址： 美版网址：
leetcode答案-leetcode:力扣编程题练习答案
06-30
leetcode 答案 leetcode 力扣编程题练习答案
leetcode第四题-LeetCode_Exercise:力扣_练习
07-01
第四题力扣_练习 位掩码 结束了一些位操作和位掩码练习，难度由低到高总结了几道非常讲的位运算和位掩码题，难度由低到高 （简单的） （简单的） （强烈推荐） （中等的） （中）（强烈推荐） （中）（强烈推荐，...
LanqQaoContest:蓝桥杯，力扣算法练习
04-01
兰考比赛蓝桥杯练习系统往届试题翻译题解包括为蓝桥杯准备刷的力扣每日一题，剑指提供，
合并两个有序链表为一个有序链表
StrangeKNL的博客
09-23 889
供学习有序链表初期使用，内部包含已经封装好了的添加链表数据的代码，同时每一步都进行了注释说明（最后附上完整代码）
LeetCode第21题—合并两个有序链表
Green_756的博客
08-13 349
LeetCode第21题、链表、数据结构
合并两个有序链表（精美图示详解哦）
weixin_73450183的博客
03-08 8254
合并两个有序链表，两种解法。有详细图示包理解哦，确定不进来看看嘛
合并两个有序链表
Crazy_Duck_Weng的博客
04-09 114
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
LeetCode 21. 合并两个有序链表
午夜的行人
02-16 203
题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 提示： 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1 和 l2 均按 非递减顺序 排列 来源：力扣（Lee
力扣LeetCode第21题合并两个有序链表
weixin_44061444的博客
04-13 1198
力扣第21题合并两个有序链表
LeetCode21
m0_53224107的博客
05-29 154
一、题目描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 二、测试数据 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 提示： 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1 和 l2 均按 非递减顺序 排列 三、分析以
【刷题之路】LeetCode 21. 合并两个有序链表
kk702392702的博客
05-07 793
空间复杂度：O(m+n)，m和n分别为两个链表的长度，空间复杂度递归调用的层数，最坏情况下，对于两个链表的每个节点我们都要调用一次，因此空间复杂度为O(m+n)。所以我们可以将思路转化为，每次调用只需要选出较小的节点然后让较小的节点连接上后面合并后的链表即可，而后面的链表的合并也是用同样的递归方式来完成。其实从上面的解法中我们也能得到启发想出一个大事化小的解法，因为我们每次的遍历只需要选出一个较小的节点，然后尾插到新链表之中。时间复杂度：O(m+n)，其中m和n分别为两个链表的长度。
力扣(LeetCode)刷题，简单题(第21期)
不脱发的程序猿
08-14 3204
力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。
力扣python题汇总
最新发布
10-18
好的，你想了解力扣Python题目的汇总，我可以为你提供一些资源。以下是一些适合初学者的力扣Python题目汇总： 1. [LeetCode 70. 爬楼梯](https://leetcode＊＊＊＊＊＊-and-sell-stock/) 3. [LeetCode 136. 只出现一次的数字](https://leetcode＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊.com/problems/reverse-linked-list/) 8. [LeetCode 217.＊＊＊＊＊＊com/problems/valid-anagram/) 10. [LeetCode 283. 移动零](https://＊＊＊哈希表等常见数据结构和算法，适合初学者练习。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值