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];
}
};