leetcode-7月8日的五题

最新推荐文章于 2021-09-13 17:36:33 发布

lwycc233

最新推荐文章于 2021-09-13 17:36:33 发布

阅读量155

点赞数

分类专栏：刷题第一轮

本文链接：https://blog.csdn.net/lwycc2333/article/details/107212397

版权

刷题第一轮专栏收录该内容

16 篇文章 0 订阅

订阅专栏

79. 单词搜索

80. 删除排序数组中的重复项 II

81. 搜索旋转排序数组 II

82. 删除排序链表中的重复元素 II

83. 删除排序链表中的重复元素Copy for Markdown

————————————————————————

79. 单词搜索

Difficulty: 中等

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

给定 word = "ABCCED", 返回 true
给定 word = "SEE", 返回 true
给定 word = "ABCB", 返回 false

提示：

board 和 word 中只包含大写和小写英文字母。
1 <= board.length <= 200
1 <= board[i].length <= 200
1 <= word.length <= 10^3

Solution：回溯法，先确定一个字符的位置，然后再去寻找剩余相邻的字符

class Solution {

    public boolean exist(char[][] board, String word) {

        int m = board.length;
        if(m <= 0) return false;
        int n = board[0].length;
        if(n <= 0) return false;


        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(board[i][j] == word.charAt(0)){
                    boolean[][] used = new boolean[m][n];
                    if(help(board, used, word, i, j, 0))  
                    			//以(i,j)开始的位置，找连续的序列
                        return true;
                }
            }
        }

        return false;
    }


    public boolean help(char[][] board, boolean[][] used, String word, int i, int j, int index){

        //System.out.println("i:"+i+",j:"+j+",index:"+index);

        if(i<0 || i>=board.length || j<0 || j>=board[0].length || used[i][j])
            return false;
        if(board[i][j]!=word.charAt(index)){
            used[i][j] = false;
            return false;
        }
        //System.out.println(", "+board[i][j]);
        if(index==word.length()-1) return true;

        used[i][j] = true;
        if(help(board, used, word, i-1, j, index+1) ||
                help(board, used, word, i, j-1, index+1) ||
                help(board, used, word, i+1, j, index+1) ||
                help(board, used, word, i, j+1, index+1)){
            return true;
        }
        used[i][j] = false;  //回溯
        return false;

    }
}

80. 删除排序数组中的重复项 II

Difficulty: 中等

给定一个排序数组，你需要在删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。

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

示例 1:

给定 nums = [1,1,1,2,2,3],

函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。

你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,0,1,1,1,1,2,3,3],

函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以**“引用”**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Solution：用一个计数count表示前面重复字符的个数

class Solution {
    public int removeDuplicates(int[] nums) {
        int k = 0, count = 1;
        for(int i=1; i<nums.length; i++){
            if(nums[i] == nums[k]){
                if(count >= 2) continue;
                else{
                    k++;
                    nums[k] = nums[i];
                    count++;
                }
            }
            else{
                k++;
                nums[k] = nums[i];
                count = 1;
            }
            
        }
        return k+1;
    }
}

81. 搜索旋转排序数组 II

Difficulty: 中等

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

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

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true

示例 2:

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false

进阶:

这是的延伸题目，本题中的 nums 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

Solution：1. 因为有重复的元素，分不清楚是左边有序还是右边有序 2. 如果左边有序； 3.如果右边有序；

时间复杂度平均：O(logn)
最坏情况下 O(n) 就是11111311111，这样的情况，相当于遍历整个数组


class Solution {
   
    public boolean search(int[] nums, int target) {
        int len = nums.length;
        if(len <= 0) return false;

        int low = 0, high = len-1, mid;
        while(low <= high){
            mid = (high-low)/2 + low;
            if(nums[mid] == target) 
                return true;

                //分不清到底是前面有序还是后面有序
            else if(nums[low] == nums[mid]) 
                low++;
            

            //如果左边有序
            else if(nums[low] < nums[mid]){

                //如果target在前半段
                if(target >= nums[low] && target <= nums[mid]){
                    high = mid-1;
                }

                //否则就去后半段找
                else{
                    low = mid+1;
                }
            }

            //如果右边有序
            else{
                //如果target在后半段
                if(target > nums[mid] && target <= nums[high]){
                    low = mid+1;
                }
                //否则就去前半段找
                else{
                    high = mid-1;
                }
            }
        }
        return false;
    }
}

82. 删除排序链表中的重复元素 II

Difficulty: 中等

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 _没有重复出现 _的数字。

示例 1:

输入: 1->2->3->3->4->4->5
输出: 1->2->5

示例 2:

输入: 1->1->1->2->3
输出: 2->3

Solution：对头结点的处理

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
    
        if(head == null) return head;
        
          // res.next一直指向头结点， cur当前应该保留的结点的最后一个结点
          //p表示遍历的结点
        ListNode res = new ListNode(-1), cur, p = head;
        res.next = head;
        cur = res;
        while(p != null){
            while(p.next != null && p.val == p.next.val){
                p = p.next;
            }
            if(cur.next == p){ //说明没有重复的
                cur = cur.next;
            }
            else{
                cur.next = p.next;
            }
            p = p.next;
        }
        cur.next = null;
        return res.next;
    }
}

83. 删除排序链表中的重复元素

Difficulty: 简单

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

Solution：头结点不会变

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null) return null;
        // cur当前应该保留的结点的最后一个结点， p表示遍历的结点
        ListNode cur = head, p = head.next;
        while(p != null){
            if(cur.val != p.val){
                cur.next = p;
                cur = cur.next;
            }
            p = p.next;
        }
        cur.next = null;
        return head;
    }
}