刷题记录4

题目1 力扣

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int a=matrix.size();
        int b=matrix[0].size();
        int n=a*b-1;
        int L=0,R=n;
        while(L<=R){
            int mid=((R-L)>>1)+L;
            int midRow=mid/matrix[0].size();
            int midCol=mid%matrix[0].size();
            if(matrix[midRow][midCol]>target){
                R=mid-1;
            }else if(matrix[midRow][midCol]<target){
                L=mid+1;
            }else{
                return 1;
            }
        }
        return 0;
    }
};

 二维矩阵可以看作数组的数组，因为整个二维矩阵有序，我们可以直接将其看作一个数组进行二分查找即可。

题目 2力扣

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

class Solution {
public:
    int findMin(vector<int>& nums) {
        int L=0,R=nums.size()-1;
        while(L<=R){
            int mid=((R-L)>>1)+L;
            if(nums[mid]<=nums.back()){
                R=mid-1;
            }else{
                L = mid+1;
            }
        }
        return nums[R+1];
    }
};

题目3 力扣 

峰值元素是指其值严格大于左右相邻值的元素。

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int L = 0,R = nums.size()-1;
        while(L<R){
            int mid = ((R-L)>>1)+L;
            if(nums[mid+1]>nums[mid]){
                L = mid+1;
            }else{
                R = mid;
            }
        }
        return R;
    }
};

简单二分查找出一个峰值即可。

题目4 力扣

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for(int i=0;i<nums.size();++i){
            int L = i+1,R = nums.size()-1;
            while(L<=R){
                int mid = ((R-L)>>1)+L;
                if(nums[mid]==target - nums[i]){
                    return {i+1,mid+1};
                }else if(nums[mid]>target - nums[i]){
                    R = mid - 1;
                }else{
                    L = mid + 1; 
                }
            }
        } 
        return {-1,-1};
    }
};

 固定第一个数，对第二个数进行二分查找。时间复杂度O(NlogN),空间复杂度O(1).

第四题 力扣

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。

你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

 

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int L = 0,R = nums.size()-1;
        while(L<R){
            int mid = ((R-L)>>1)+L;
            int count = 0;
            for(int n : nums){
                if(n<=mid){
                    count++;
                }
            }
            if(count>mid){
                R = mid;
            }else{
                L = mid + 1;
            }
        } 
        return L;
    }
};

首先遍历一次数组，统计出比中点小的数字的个数count，如果count比中点值大，说明在左半部分，反之在右半部分；重复以上过程即可得到重复的数字的具体情况。

第五题 力扣

给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。

根据维基百科上 h 指数的定义：h 代表“高引用次数”，一名科研人员的 h指数是指他（她）的 （n 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。且其余的 n - h 篇论文每篇被引用次数 不超过 h 次。

如果 h 有多种可能的值，h 指数 是其中最大的那个。

class Solution {
public:
    int hIndex(vector<int>& citations) {
        sort (citations.begin(),citations.end());
        int h = 0,i = citations.size()-1;
        while(i>=0&&citations[i]>h){
            h++;
            i--;
        }
        return h;
    }
};

简单遍历一次使用H计数即可

第六题 力扣

给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数，citations 已经按照 升序排列 。计算并返回该研究者的 h 指数。

h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （n 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。且其余的 n - h 篇论文每篇被引用次数 不超过 h 次。

提示：如果 h 有多种可能的值，h 指数 是其中最大的那个。

请你设计并实现对数时间复杂度的算法解决此问题。

class Solution {
public:
    int hIndex(vector<int>& citations) {
        int n=citations.size();
        int L= 0,R = citations.size()-1;
        while(L<R){
            int mid = ((R - L)>>1)+L;
            if(citations[mid]>=n-mid){
                R = mid;
            }else{
                L= mid +1;
            }
        }
        return citations[R]>=n-R?n-R:0;
    }
};

 相较于上一个题目数字增加了有序的条件，可以使用二分法查找出满足H指数条件的下标，在计算出H指数即可。

题目7 力扣

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。 

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int n1=nums1.size();
        int n2=nums2.size();
        vector<int> res;
        unordered_set<int> st(nums1.begin(),nums1.end());
        for(int i=0;i<n2;i++){
                if(st.count(nums2[i])){
                    res.push_back(nums2[i]);
                    st.erase(nums2[i]);
                }
            }
        return res;
    }
};

首先创建一个hashmap，将nums1的数字储存进去，然后遍历nums2，如果出现相同的就把这个数字储存进结果数组中。

题目8力扣

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        int n1 =nums1.size();
        int n2 =nums2.size();
        if(n1>n2){
            return intersect(nums2,nums1);
        }
        unordered_map<int,int>m;
        for(int n:nums1){
            ++m[n];
        }
        vector<int>res;
        for(int n:nums2){
            if(m.count(n)){
                res.push_back(n);
                --m[n];
                if(m[n]==0){
                    m.erase(n);
                }
            }  
        }
        return res;
    }
};

 因为这个题目中同一个数字可以出现多次，我们首先创建一个hash数组来储存数字与对应的个数，再遍历nums2，如果找到相同的元素就把这个数储存近结果数组中。

题目9 力扣

 给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while(cur){
            ListNode*next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
        }
};

 

 

 题目10 力扣

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        ListNode* pre=nullptr;
        ListNode* cur=head;
        while(cur){
            ListNode*next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        vector<int>result;
        if(pre == nullptr){
            return result;
        }
        while(pre){
            result.push_back(pre->val);
            pre = pre->next;
        }
        
        return result;
    }
};

 先反转链表，再把链表中的值提取到数组中，最后打印即可。