leetcode-热题100(3)

矩阵最后一列升序排序，在最后一列中查找第一个大于等于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;
}

leetcode-33-搜索旋转排序数组

题意为：在一个旋转过的数组中查找目标值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;
}

leetcode-153-寻找旋转排序数组中的最小值

如果nums[mid] > nums[right] ，那么最小值一定在(mid,right)中

如果nums[mid] <= nums[right] ，那么最小值一定在(left,mid)中

边界：left == right 此时最小值就是nums[left]

复制代码

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

leetcode-4-寻找两个正序数组的中位数

暴力

复制代码

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

leetcode-155-最小栈

leetcode--394-字符串解码

leetcode-739-每日温度

暴力

复制代码

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，赋值ans[0] = 1-0，将1入栈

stack = { 1(74) }

ans = {1,0,0,0,0,0,0,0}

当i = 2时，由于75大于74，因此移除栈顶元素1，赋值ans[1] = 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，赋值ans[4] = 5-4 和 ans[3] = 5-3，将5入栈

stack = { 2(75) ，5(72)}

ans = {1,1,0,2,1,0,0,0}

当i = 6时，由于76大于72和75，因此依次移除栈顶元素5和2，赋值ans[5] = 6-5 和 ans[2] = 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;
}

leetcode-84-柱状图中最大矩形

leetcode-215-数组中的第K大元素

leetcode-121-买卖股票的最佳时机