133tC0d3^240318

238. 除自身以外数组的乘积https://leetcode.cn/problems/product-of-array-except-self/

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。

请 不要使用除法，且在 O(n) 时间复杂度内完成此题。

思路：nums的值等于pre*pos；

nums	1	2	3	4
pre	1	2	6	24
pos	24	24	12	4

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();
        vector<int> L(length ,0) , R(length,0);

        vector<int> answer(length);
        L[0]=1;
        for(int i=1;i<length;i++){
            L[i]=nums[i-1]*L[i-1];
        }
        R[length-1]=1;
        for(int i=length-2;i>=0;i--){
            R[i]=nums[i+1]*R[i+1];
        }
        //求nums左右的乘积
        for(int i=0;i<length;i++){
            answer[i]=L[i]*R[i];
        }
        return answer;
}
};

153. 寻找旋转排序数组中的最小值https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array/

提示

已知一个长度为 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 low = 0;
        int high = nums.size()-1;
        while(low<high){
            int p=low+(high-low)/2;
            if(nums[p]<nums[high]){
                high = p;
            }
            else{
                low = p+1;
            }
        }
        return nums[low];
    }
};

215. 数组中的第K个最大元素https://leetcode.cn/problems/kth-largest-element-in-an-array/

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

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

思路：使用栈排序来计算

class Solution {
public:
    void maxHeapify(vector<int>&a,int i,int heapSize){
        int l=i*2+1,r=i*2+2,largest=i;
        if(l<heapSize && a[l]>a[largest]){
            largest=l;
        }
         if(r<heapSize && a[r]>a[largest]){
            largest=r;
        }
        if(largest!=i){
            swap(a[i],a[largest]);
            maxHeapify(a,largest,heapSize);
        }
    }
    void buildMaxHeap(vector<int>& a,int heapSize){
        for(int i=heapSize/2;i>=0;--i){
            maxHeapify(a,i,heapSize);
        }
    }//首先进行初始化
    int findKthLargest(vector<int>& nums, int k) {
        int heapSize=nums.size();
        buildMaxHeap(nums,heapSize);
        for(int i=nums.size()-1;i>=nums.size()-k+1;--i){
            swap(nums[0],nums[i]);
            --heapSize;
            maxHeapify(nums,0,heapSize);
        }
//使用栈排序来计算结构
        return nums[0];
    }
};