《LeetCode零基础指南》(第四讲) 一维数组

1. 搜索旋转排序数组

33. 搜索旋转排序数组

• 题目

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

直接遍历数组中的所有元素，找出符合条件的值返回即可

• 源码实现

int search(int* nums, int numsSize, int target){
    //搜索旋转排序数组
    //先搜索到目标值，如果没搜到那么直接返回-1
    int i;
    int k = -1;
    for(i = 0; i < numsSize; ++i)
    {
        if(nums[i] == target)
        {
            k = i;
        }
    }

    if(k == -1) //没有找到目标整数
    {
        return -1;
    }
    else
    {
        return k;
    }

}

2. 搜索旋转排序数组 II

搜索旋转排序数组 II

• 题目

已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k< nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

暴力法：直接遍历数组中的所有元素

• 源码实现

bool search(int* nums, int numsSize, int target){
    int i;
    for(i = 0; i < numsSize; ++i)
    {
        if(nums[i] == target)
        {
            return true;
        }
    }

    return false;
}

3. 4的幂

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

• 题目

已知一个长度为 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 ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

思路一：

​ 暴力解法，直接遍历所有的元素，找出最小的值返回

思路二：

​ 递归，我们将数组不断地一分为二，先求左边的最小值，然后再求右边的最小值，最后将左右的最小值互相比较求出结果。

• 源码实现

int process(int *nums, int L, int R)
{
    if(L == R)
    {
        return nums[L];
    }
    int mid = L + ((R - L)>>1);	//防止溢出
    int leftMin = process(nums, L, mid);	//往左边递归求出最小值
    int rightMin = process(nums, mid + 1, R);	//往右边递归求出最小值

    return fmin(leftMin, rightMin);	//返回左右值中的最小值
}

int findMin(int* nums, int numsSize){
    if(numsSize == 1 || nums == NULL)	//为空或为1直接返回，无需比较
    {
        return *nums;
    }
    return  process(nums, 0, numsSize - 1);
}

4. 爬楼梯

70. 爬楼梯

• 题目

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

**注意：**给定n 是一个正整数。

• 思路分析

斐波那契的变形，可以采用递归的做法，但是时间会超出限制。

这里采用动态规划来做（参照的题解），定义三个变量，分别保存第一个、第二个的值，第三个变量是前两个值相加的结果。每次循环向前移动一位。

• 源码实现

int climbStairs(int n){
    if(n <= 0)
    {
        return -1;
    }
    //滚动数组
    int i;
    int p = 0, q = 0, r = 1;
    for(i = 1; i <= n; ++i)
    {
        p = q;	//循环更新第一个变量值
        q = r;	//循环更新第二变量值
        r = p + q;	//两个变量值相加
    }

    return r;
}

5. 斐波那契数

509. 斐波那契数

• 题目

斐波那契数，通常用·F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给你 n ，请计算 F(n) 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fibonacci-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

递归求解，基准条件是n == 0 时返回0，n == 1返回1

• 源码实现

int fib(int n){
    if(n == 0)
    {
        return 0;
    }
    if(n == 1)
    {
        return 1;
    }
    return fib(n - 1) + fib(n - 2);
}

6. 第N个泰波那契数

1137. 第 N 个泰波那契数

• 题目

泰波那契序列 Tn 定义如下：

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/n-th-tribonacci-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

首先将问题分化，将问题分解到不能再分，找出递增的条件，根据这两个结果我们就可以求解出答案

• 源码实现

int tribonacci(int n){
    int dp[40];
    if(n < 0)
        return -1;
    
    int i;
    dp[0] = 0;	//基本情况
    dp[1] = 1;
    dp[2] = 1;
    for(i = 3; i <= n; ++i)
    {
        dp[i] = dp[i -3] + dp[i - 2] + dp[i - 1];	//公式求解
    }

    return dp[n];	//返回n的结果
}

7. 拿硬币

LCP 06. 拿硬币

• 题目

桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。

• 题目分析

（参照别人的思路）利用贪心思想，每次先与最大值比较，在与次大的值比较。细心分析可知，每次将硬币值加1除2即可得知当前拿硬币的最少次数，依次相加求出最终结果

• 源码实现

int minCount(int* coins, int coinsSize){
    int i;
    int ans = 0;

    for(i = 0; i < coinsSize; ++i)
    {
        ans += (coins[i] + 1) / 2;
    }

    return ans;
}

8. 猜数字

LCP 01. 猜数字

• 题目

小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？

输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/guess-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

两两比较就可以得知猜对次数

• 源码实现

int game(int* guess, int guessSize, int* answer, int answerSize){
    int i;
    answerSize = 0;
    for(i = 0; i < guessSize; ++i)
    {
        if(guess[i] == answer[i])
        {
            answerSize++;
        }
    }

    return answerSize;
}

9. 差的绝对值为K的数对数目

2006. 差的绝对值为 K 的数对数目

• 题目

给你一个整数数组 nums 和一个整数 k ，请你返回数对 (i, j) 的数目，满足 i < j 且 |nums[i] - nums[j]| == k 。

|x| 的值定义为：

如果 x >= 0 ，那么值为 x 。
如果 x < 0 ，那么值为 -x 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

双层循环找出所有满足差值为K的情况，注意使用abs函数将差值为负数的值变为正数

• 源码实现

int countKDifference(int* nums, int numsSize, int k){
    /* 1.使用abs函数比较差值 */
    int i, j,cnt = 0;
    for(i = 0; i < numsSize - 1; ++i)
    {
        for(j = i + 1; j < numsSize; ++j)
        {
            if(abs(nums[i] - nums[j]) == k)
            {
                cnt++;
            }
        }
    }

    return cnt;
}