剑指offer-查找专题

剑指offer-查找专题

LCR 120.寻找文件副本

class Solution {
    public int findRepeatDocument(int[] documents) {
        //1.双层for循环超时
        // int res=0;
        // for(int i=0;i<documents.length;i++){
        //     for(int j=i+1;j<documents.length;j++){
        //         if(documents[i]==documents[j]){
        //              res=documents[i];
        //              break;
        //         }
        //     }
        // }
        // return res;

        //2.哈希表
        //hashset的contains()函数时间复杂度O(1)~O(n)
        Set<Integer> dic=new HashSet<>();
        for(int i=0;i<documents.length;i++){
            if(dic.contains(documents[i])) return documents[i];
            dic.add(documents[i]);
        }
        return -1;


        //3.排序+一遍遍历
        
        // Arrays.sort(documents);
        // for(int i = 0 ; i < documents.length-1 ;i++){
        //     if(documents[i]==documents[i+1]) return documents[i];
        // }   
        // return -1;
    }
}

思考

首先试了下简单的双层for循环，超时。利用哈希表存储，遍历一次用contains函数查找，时间复杂度为O1，最后排序+一遍遍历，sort用的应该是快排，时间复杂度为logn。

LCR 172.统计目标成绩出现次数

class Solution {
    public int countTarget(int[] scores, int target) {
        // int res=0;
        // for(int i=0;i<scores.length;i++){
        //     if(scores[i]==target){
        //         res++;
        //     }
        // }
        // return res;

        int leftIdx = binarySearch(scores, target, true);
        int rightIdx = binarySearch(scores, target, false);
        // if (leftIdx <= rightIdx && rightIdx < scores.length && scores[leftIdx] == target && scores[rightIdx] == target) {
        //     return rightIdx - leftIdx + 1;
        // } 
        // return 0;
        return rightIdx - leftIdx;

    }
    public int binarySearch(int[] nums, int target, boolean lower) {
        int left = 0, right = nums.length - 1, ans = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }

}

思考

两种方法，一是暴力，但是没有利用到递增信息，二是二分查找，时间复杂度更优，为O(logn)

LCR 173.点名

class Solution {
    public int takeAttendance(int[] record) {
        // for(int i=0;i<record.length;i++){
        //     if(record[i]!=i) return i;
        // }
        // return record.length;

        int i=0,j=record.length-1;
        while(i<=j){
            int m=(i+j)/2;
            if(record[m]==m) i=m+1;
            else j=m-1;
        }
        return i;
    }
}

思考

有序的数组多考虑二分查找

LCR 121.寻找目标值-二维数组

class Solution {
    public boolean findTargetIn2DPlants(int[][] plants, int target) {
        
        int m=plants.length;
        if(m==0) return false;
        int n=plants[0].length;
        int i=m-1,j=0;
        while(i>=0&&j<n){
            if(plants[i][j]>target) i--;
            else if(plants[i][j]<target) j++;
            else return true;
        }
        return false;
    }
}

思考

暴力虽然能解但是可能会超时，可以选择从矩阵左下角和右上角开始遍历，类似二叉搜索树。

LCR 128.库存管理I

class Solution {
    public int stockManagement(int[] stock) {
        Arrays.sort(stock);
        return stock[0];
    }
}

没get题目意思，看原题

//方法一
//虽然定义为困难题，但是用一遍遍历即可实现
class Solution {
    public int findMin(int[] nums) {
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]>nums[i+1]){
                return nums[i+1];
            }
            
        }
        return nums[0];
    }
}

//方法二：二分查找
class Solution {
    public int findMin(int[] nums) {
        int i = 0, j = nums.length - 1;
        while (i < j) {
            int m = (i + j) / 2;
            if (nums[m] > nums[j]) i = m + 1;
            else if (nums[m] < nums[j]) j = m;
            else j--;
        }
        return nums[i];
    }
}

思考

此题的要求应该是用二分查找解题，只需比较中间与右边的数的大小来控制区间。

LCR 169.招式拆解II

class Solution {
    public char dismantlingAction(String arr) {
        for(int i=0;i<arr.length();i++){
            char value=arr.charAt(i);
            if(arr.indexOf(value)==arr.lastIndexOf(value)){
                return value;
            }

        }
        return ' ';
    }
}

思考

题比较简单，方法比较多，可以用哈希表记录，操作的时候最好用toCharArray()转为数组，以上代码查找字符出现的一个位置和最后一个位置，判断是否相同，其时间复杂度较高。