LeetCode寒假刷题 Day05

---

前言

今天是寒假LeetCode刷题打卡的第五天，加油加油！也希望我的博文能够帮助到大家。

一、023 合并K个升序链表

1. 题目描述

题号：23
难度：困难
023 合并K个升序链表
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入: [ 1->4->5,
1->3->4,
2->6 ]
输出: 1->1->2->3->4->4->5->6

2. 解题思路

采用两两合并的思想，用到了在昨天的 LeetCode寒假刷题Day04 中的021题——两个有序链表合并为一个有序链表，然后依次进行两两合并。

3. 代码实现

class Solution {
   public ListNode mergeKLists(ListNode[] lists) {
        ListNode ans = null;
        for (int i = 0; i < lists.length; ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null)
            return l2;
        ListNode head1=new ListNode(0,l1);
        l1=head1;
        ListNode head2=new ListNode(0,l2);
        ListNode now=l2;
        while(head1.next!=null&&head2.next!=null)
        {
            if(head2.next.val<head1.next.val)
            {
                now=head2.next;
                head2.next=now.next;
                now.next=head1.next;
                head1.next=now;
                head1=now;

            }
            else
            {
                head1=head1.next;
            }

        }
        while(head2.next!=null)
        {
            now=head2.next;
            head2.next=now.next;
            now.next=head1.next;
            head1.next=now;
            head1=now;
        }
        l1=l1.next;
        return l1;
    }
}

二、026 删除排序数组中的重复项

1. 题目描述

题号：26
难度：简单
026 删除排序数组中的重复项
给定一个 排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,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。
你不需要考虑数组中超出新长度后面的元素。

2. 解题思路

说起这道题，其实不是第一次见了。我研究生同学前两天面试字节，然后就考了这道题。因此做的时候也比较有思路。

具体的思路就是双指针（快慢指针），j慢i快，开始时j=0，i=1。当nums[j] == nums[i]时，for循环中的i++就可以跳过重复项，不相等时，让nums[++j] = nums[i]，然后让i++，把值复制过来继续执行到末尾即可，时间复杂度为 O(n)。

3. 代码实现

class Solution {
    public int removeDuplicates(int[] nums) {
        int i,j=0,count=0;
        for(i=1;i<nums.length;i++)
        {
            if(nums[i]!=nums[j])
            {
                nums[++j]=nums[i];
            }
            else
            {
                count++;
                nums[j]=nums[i];
            }
        }
        return nums.length-count;
    }
}

三、033 搜索旋转排序数组

1. 题目描述

题号：33
难度：中等
033 搜索旋转排序数组
假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
示例 3:

输入: nums = [5,1,3], target = 5
输出: 0
示例 4:

输入: nums = [4,5,6,7,8,1,2,3], target = 8
输出: 0
示例 5:

输入: nums = [3,1], target = 1
输出: 1

2. 解题思路

看到这个时间复杂度，自然是想到用二分查找。但是整个数组不是全局有序的，只是部分有序。这时，我们想到二分查找时，两边必然至少有一个部分有序，我们只需考虑无序和有序这两种情况分别处理。

3. 代码实现

class Solution {
    public int search(int[] nums, int target) {
        int l=0,r=nums.length-1,mid;
        while(l<=r)
        {
            mid=(l+r)>>1;
            if(nums[mid]==target)
                return mid;
            if(nums[mid]>=nums[l])
            {
                if (nums[l]<=target&&target<nums[mid])
                    r=mid-1;
                else
                    l=mid+1;
            }
            else
            {
                if (nums[mid]<target&&target<=nums[r])
                    l=mid+1;
                else
                    r=mid-1;
            }
        }
        return -1;
    }
}

总结

以上就是今天LeetCode寒假刷题Day05所做的三道题。若有任何疑问，欢迎私信或评论区留言鸭！