[学习报告]《LeetCode零基础指南》(第四讲) 数组

Amy卜bo皮 Amy卜bo皮 墨衍会员 · AI 创作全网分发 墨衍智能分发 通过墨衍一键同步至各平台 可同步平台 CSDN微信公众号微博知乎掘金百家号博客园抖音小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年,写一次发全网 我也要 + 加入社区
  1. 数组是数的排列,分为有序和无序,可以模拟很多数据组
  2. 数组可以用来循环处理,在C中需要知道数组的大小只能通过一个表示长度的变量进行传递
int search(int* nums, int numsSize, int target){
    int res;
    int left = 0;
    int right = numsSize - 1;
    int mid = (left + right) / 2;

    while (left <= right) {
        printf ("%d, %d, %d\n", left, mid, right);
        if (nums[mid] == target) {
            return mid;
        }

        if (nums[left] == target) {
            return left;
        }

        if (nums[right] == target) {
            return right;
        }

        // left is a sorted array
        if (nums[left] < nums[mid]) {
            if (nums[mid] < target) {
                left = mid + 1;
                right -=1;
            } else {
                left += 1;
                right -=1;
            }
        } else {
        // right is sorted
            if (nums[mid] > target) {
                left += 1;
                right = mid - 1;
            } else {
                left += 1;
                right -=1;
            }
        }
        mid = (left + right) / 2;
    }

    return -1;
}

旋转有序数组也可以二分法

bool search(int* nums, int numsSize, int target) {
    if (numsSize == 0) {
        return false;
    }
    if (numsSize == 1) {
        return nums[0] == target;
    }
    int l = 0, r = numsSize - 1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (nums[mid] == target) {
            return true;
        }
        if (nums[l] == nums[mid] && nums[mid] == nums[r]) {
            ++l;
            --r;
        } else if (nums[l] <= nums[mid]) {
            if (nums[l] <= target && target < nums[mid]) {
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        } else {
            if (nums[mid] < target && target <= nums[numsSize - 1]) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
    }
    return false;
}
int findMin(int* nums, int numsSize){
    int left = 0;
    int right = numsSize - 1;
    int mid = (left + right) / 2;

    do {
        ///< when the graph is like ^V
        if (nums[left] > nums[right]) {
            ///< narrow the border, follow the trend
            left = nums[mid] > nums[left] ? mid : left;
            right = nums[mid] < nums[right] ? mid : right;
            mid = (left + right) / 2;
        } else { ///< is like A
            return nums[left];
        } 
    } while (1 != (right - left)) ;

    ///< is like V 
    return nums[right];
}
struct Matrix {
    long long mat[2][2];
};

struct Matrix multiply(struct Matrix a, struct Matrix b) {
    struct Matrix c;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            c.mat[i][j] = a.mat[i][0] * b.mat[0][j] + a.mat[i][1] * b.mat[1][j];
        }
    }
    return c;
}

struct Matrix matrixPow(struct Matrix a, int n) {
    struct Matrix ret;
    ret.mat[0][0] = ret.mat[1][1] = 1;
    ret.mat[0][1] = ret.mat[1][0] = 0;
    while (n > 0) {
        if ((n & 1) == 1) {
            ret = multiply(ret, a);
        }
        n >>= 1;
        a = multiply(a, a);
    }
    return ret;
}

int climbStairs(int n) {
    struct Matrix ret;
    ret.mat[1][1] = 0;
    ret.mat[0][0] = ret.mat[0][1] = ret.mat[1][0] = 1;
    struct Matrix res = matrixPow(ret, n);
    return res.mat[0][0];
}

int f[1000];                      // (1)
int climbStairs(int n){
    f[0] = f[1] = 1;              // (2)
    for(int i = 2; i <= n; ++i) {
        f[i] = f[i-1] + f[i-2];   // (3)
    }
    return f[n];                  // (4)
}
int fib(int n){
    int f0 = 0;
    int f1 = 1;
    int fn = f0 + f1;

    while (n > 1) {
        fn = f0 + f1;
        f0 = f1;
        f1 = fn;
        n--;
    }

    if (n < 1) return f0;

    return fn;
}
int tribonacci(int n){
    int T[4] = {0, 1, 1, 2};
    enum {first = 0, second, curr, next};

    if (n < 4) {
        return T[n];
    }

    for (int i = 3; i <= n; ++i) {
        T[next] = T[first] + T[second] + T[curr];
        T[first] = T[second];
        T[second] = T[curr];
        T[curr] = T[next];
    }

    return T[curr];
}
int countKDifference(int* nums, int numsSize, int k){
    int res = 0;

    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            int judge = abs(nums[i] - nums[j]);

            if (judge == k) {
                res++;
            }
        }
    }
    
    return res;
}
int game(int* guess, int guessSize, int* answer, int answerSize){
    int res = 0;
    for (int i = 0; i < 3; ++i) {
        if (guess[i] == answer[i]) {
            ++res;
        }
    }
    return res;
}
int minCount(int* coins, int coinsSize){
    int res = 0;
    for (int i = 0; i < coinsSize;) {
        if (coins[i] > 0) {
            ++res;
            coins[i] -= 2;
        } else {
            ++i;
        }
    }

    return res;
}
...全文

相关推荐

leetcode第四题-LeetCode_Exercise:力扣_练习

leetcode 第四题力扣_练习 位掩码 结束了一些位操作和位掩码练习,难度由低到高总结了几道非常讲的位运算和位掩码题,难度由低到高 (简单的) (简单的) (强烈推荐) (中等的) (中)(强烈推荐) (中)(强烈推荐,即使你能想到每个元素出现4、5、6次而只有一个出现1次的问题,你怎么解决) (中)(强烈推荐) (难)(强烈推荐) 为什么我们需要使用Bitmask来处理一些棘手的问题? 原因1:位操作比'+-*/'等正常操作更快 原因2:位掩码可以帮助我们记录状态。 如果您使用 int 变量或布尔变量来存储状态,它将花费 4 个字节,因此您使用位 0/1 来存储状态,这将节省大量空间。 一些位掩码的操作: 1.记录状态 如果您有 8 个状态,则可以将位掩码设为 00000000,并使用“或 |” 操作以保存您的状态。 例如。 位掩码 = 00000000 new_state1 = 00001000 位掩码 | new_state1 = 00001000 这意味着已经记录了第四个状态 new_state2 = 00010001 位掩码 | new_state2 = 00011001

weixin_38684743

Leetcode:力扣个人代码C ++

Leetcode:力扣个人代码C ++

皮卡学长

Leet Code_力扣原题_leetcode官网_

力扣网原题,可用于求职刷题,每个程序代码都正确。

kikikuka

leetcode卡-LeetCode:力扣解决方案

leetcode卡30 天 LeetCoding 挑战 挑战信息:

weixin_38590784

leetcode下载-leetcode:力扣的练习题

leetcode下载 简介 是不是有许多小伙伴在刷力扣的时候感觉无从下手?从头按顺序开始刷的童鞋们可能会比较有感触,为什么才第四题就感觉很难了?没关系,本文将对力扣的 1-700 题中不需要会员的数据结构与算法题目(数据库与 shell 除外)进行分类,并推荐一个刷题的顺序。 完全零基础可以刷题吗? 不能,至少要基本掌握一门计算机语言的语法。但现在在网上随便搜一下就能搜到许多关于计算机语言的教程。当然,最好还是上一下正规的课程。 刷题顺序很重要吗? 重要。按照题目类别结构化地刷题的速度不仅更快,而且可以在刷完一类题之后进行总结。对于水平较高的小伙伴们来说,按照推荐的顺序刷,可以在 200 小时内刷完 500 多题。对于萌新们来说,按照推荐顺序刷,能更好地掌握数据结构与算法基础。 题目分类及刷题顺序推荐 一. 数组 题目分类 题目编号 数组的遍历 485、495、414、628 统计数组中的元素 645、697、448、442、41、274 数组的改变、移动 453、665、283 二维数组及滚动数组 118、119、661、598、419 数组的旋转 189、396 特定顺序遍历二维数

weixin_38507208
评论
收藏 已收藏
分享
返回顶部
Amy卜bo皮
万人千题 64,204 成员 15,010 内容