矩阵最后一列升序排序，在最后一列中查找第一个大于等于target的元素
然后在该元素所在行进行二分查找
bool searchMatrix(int** matrix, int matrixSize, int* matrixColSize, int target) {
int n = matrixSize;
int m = matrixColSize[0];
int i;
for(i = 0 ; i < n ; i++){
if(target <= matrix[i][m-1]){
int l = 0, r = m-1;
while(l <= r){
int mid = (r+l)/2;
if(target > matrix[i][mid])
l = mid+1;
else if(target < matrix[i][mid])
r = mid-1;
else
return true;
}
return false;
}
}
return false;
}题意为：在一个旋转过的数组中查找目标值target，若存在返回其下标，否则返回-1
将数组一分为二，其中一定有一个是有序的，另一个可能是有序，也能是部分有序。 此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样循环.
int search(int* nums, int numsSize, int target) {
int n = numsSize;
if(n == 0)
return -1;
if(n ==1)
return nums[0] == target ? 0 : -1;
int l = 0, r = n-1;
while(l <= r){
int mid = (l+r)/2;
if(nums[mid] == target)
return mid;
if(nums[0] <= nums[mid]){
if(nums[0] <= target&& target <= nums[mid]){
r = mid-1;
}else{
l = mid +1;
}
}
else{
if(nums[mid] < target && target <= nums[n-1]){
l =mid+1;
}else{
r = mid-1;
}
}
}
return -1;
}如果numsmid > numsright ，那么最小值一定在(mid,right)中
如果numsmid <= numsright ，那么最小值一定在(left,mid)中
边界：left == right 此时最小值就是numsleft
int findMin(int* nums, int numsSize) {
if(numsSize == 1)
return nums[0];
int n = numsSize;
int l = 0, r = n-1;
int res = nums[0];
while(l <= r){
int mid = (l+r)/2;
res = fmin(res,nums[mid]);
if(nums[mid] > nums[r])
l = mid+1;
else
r = mid-1;
}
return res;
}暴力
int* combine(int* nums1, int nums1Size, int* nums2, int nums2Size){
int* nums = (int*)malloc(sizeof(int)*(nums1Size+nums2Size));
int i,j,index;
i = 0 , j = 0, index = 0;
while(i < nums1Size && j < nums2Size){
if(nums1[i] <= nums2[j]){
nums[index++] = nums1[i];
i++;
}else{
nums[index++] = nums2[j];
j++;
}
}
if(i < nums1Size){
while(i < nums1Size){
nums[index++] = nums1[i++];
}
}
if(j < nums2Size){
while(j < nums2Size){
nums[index++] = nums2[j++];
}
}
return nums;
}
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
int* nums = combine(nums1,nums1Size,nums2,nums2Size);
double res = 0;
int mid = 0;
if((nums1Size+nums2Size) % 2 == 0){
mid = (nums1Size+nums2Size-1)/2;
res = (double)(nums[mid] + nums[mid+1])/2;
}else{
mid = (nums1Size+nums2Size-1)/2;
res = (double)nums[mid];
}
return res;
}暴力
int* dailyTemperatures(int* temperatures, int temperaturesSize, int* returnSize) {
int* res = (int*)malloc(sizeof(int)*temperaturesSize);
memset(res,0,sizeof(int)*temperaturesSize);
int* next = (int*)malloc(sizeof(int)*101);
for(int i = 0 ; i <= 100 ; i++){
next[i] = INT_MAX;
}
for(int i = temperaturesSize-1 ; i >= 0 ; i--){
int index = INT_MAX;
for(int t = temperatures[i]+1 ; t <= 100 ; t++){
if(next[t] < index){
index = next[t];
}
}
if(index < INT_MAX){
res[i] = index-i;
}
next[temperatures[i]] = i;
}
*returnSize = temperaturesSize;
return res;
}单调栈：当要入栈元素大于栈顶元素时，更新栈顶元素中res的值，并将栈顶元素移除
当要入栈元素小于栈顶元素时，直接入栈
判别是否需要使用单调栈，如果需要找到左边或者右边第一个比当前位置的数大或者小，则可以考虑使用单调栈
模拟过程：
当i = 0时，单调栈为空，将0进栈
stack = { 0(73) }
ans = {0,0,0,0,0,0,0,0}
当i = 1时，由于74大于73，因此移除栈顶元素0，赋值ans0 = 1-0，将1入栈
stack = { 1(74) }
ans = {1,0,0,0,0,0,0,0}
当i = 2时，由于75大于74，因此移除栈顶元素1，赋值ans1 = 2-1，将2入栈
stack = { 2(75) }
ans = {1,1,0,0,0,0,0,0}
当i = 3时，由于71小于75，将3入栈
stack = { 2(75)，3(71) }
ans = {1,1,0,0,0,0,0,0}
当i = 4时，由于69小于71，将4入栈
stack = { 2(75)，3(71) ，4(69)}
ans = {1,1,0,0,0,0,0,0}
当i = 5时，由于72大于69和71，因此依次移除栈顶元素4和3，赋值ans4 = 5-4 和 ans3 = 5-3，将5入栈
stack = { 2(75) ，5(72)}
ans = {1,1,0,2,1,0,0,0}
当i = 6时，由于76大于72和75，因此依次移除栈顶元素5和2，赋值ans5 = 6-5 和 ans2 = 6-2，将6入栈
stack = { 6(76) }
ans = {1,1,0,2,1,1,0,0}
当i = 7时，由于73小于76，将7入栈
stack = {6(76)，7(73)}
ans = {1,1,4,2,1,1,0,0}
typedef struct stkNode{
int val;
int index;
}stkNode;
stkNode* getNode(int val, int i){
stkNode* node = (stkNode*)malloc(sizeof(stkNode));
node->val = val;
node->index = i;
return node;
}
int* dailyTemperatures(int* temperatures, int temperaturesSize, int* returnSize) {
int* res = (int*)malloc(sizeof(int)*temperaturesSize);
memset(res,0,sizeof(int)*temperaturesSize);
stkNode** stk = (stkNode**)malloc(sizeof(stkNode*)*temperaturesSize);
int stk_top = 0;
for(int i = 0 ; i < temperaturesSize ; i++){
stkNode* node = getNode(temperatures[i],i);
if(stk_top == 0){
stk[stk_top++] = node;
}else{
while(stk_top > 0 && stk[stk_top-1]->val < temperatures[i]){
stk_top--;
int j = stk[stk_top]->index;
res[j] = i-j;
}
stk[stk_top++] = node;
}
}
*returnSize = temperaturesSize;
return res;
}