九日集训第三天《一维数组》

文章目录

今日知识总结

1. 定义一维数组方式

   int a[7];//只是开辟出了空间
   int a[7] = {0, 1, 2, 3, 4, 5, 6}//不仅开辟了空间，还将元素储存到了空间里
   
   int a[] = {0, 1, 2, 3, 4, 5, 6}//如果初始化列表里已经知道有多少个元素，那么括号中的数字可以省略
   
   int a[28] = {0, 1, 2, 3, 4, 5, 6}//我们也可以定义一个大数组，值初始化其中的几个元素
   

2. 长度和容量：长度不允许超过容量

3. 数组的索引：从零开始，所以数组的最大下标是数组的长度减一

4. 数组的参数传参

   int add(int[] nums){
       
   }
   
   //力扣上也会写成如下形式
   int add(int* nums){
       
   }
   

题目分析

1. 33. 搜索旋转排序数组

   1. 题目链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array/

   2. 思路：

      • 直接比遍历一便数组，如果能找到等于目标的值，就返回他的下标，这样做的时间复杂度为o(n),不满足题目要求
      • 题目说明是有序数组，那么，把数组旋转可能只有几种关系，可以考虑用二分查找来进行查询，此时的时间复杂度为O(logn)

   3. 代码：

      • 思路一代码：

        class Solution {
        public:
            int search(vector& nums, int target) {
                for(int i = 0; i < nums.size(); i++){
                    if(nums[i] == target) return i;
                }
        
                return -1;
        
            }
        };
        

      • 思路二代码：

2. 81. 搜索旋转排序数组 II

   1. 题目链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/

   2. 思路：遍历一遍数组

   3. 代码：

      class Solution {
      public:
          bool search(vector& nums, int target) {
              for(int i = 0; i < nums.size(); i++){
                  if(nums[i] == target) return true;
              }
      
              return false;
      
          }
      };
      

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

   1. 题目链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/

   2. 思路：二分查找，具体思路链接参照：https://blog.csdn.net/songyaxuanwoai/article/details/123833818?spm=1001.2014.3001.5502

   3. 代码：

      class Solution {
      public:
          int findMin(vector& nums) {
             int left, right, mid;
             left = 0, right = nums.size() - 1, mid = 0;
             while(left < right){
                 mid = (right - left) / 2 + left;
                 if(nums[right] < nums[mid]) {
                     left = mid + 1;
                 }
                 else if(nums[right] > nums[mid]){
                     right = mid;
                 }
                 
             }
             return nums[left];
          }
      };
      

4. 70. 爬楼梯

   1. 题目链接：https://leetcode-cn.com/problems/climbing-stairs/

   2. 思路：动态规划

      • 定义一个数组f[46],来记录到达最顶层台阶的方法数，由题意可得，到达第0层，和到达第一层只有一种方法，那么到达第n层的方法数只取决于到达第n -1层的方法数以及到达第n - 2层的方法数，可以得到状态转移方程为$f[n]=f[n-1]+f[n-2]$

      3.代码：

      class Solution {
      public:
          int climbStairs(int n) {
              int f[46] = {1, 1};
      
              for(int i = 2; i <= n; i++){
                  f[i] = f[i - 1] + f[i - 2];
              }
      
              return f[n];
      
      
          }
      };
      

5. 509. 斐波那契数

   1. 题目链接：https://leetcode-cn.com/problems/fibonacci-number/

   2. 思路：动态规划

   3. 代码：

      class Solution {
      public:
          int fib(int n) {
              
              int f[n + 1];
              if(n == 0) f[0] = 0;
              else{
                  f[0] = 0;
                  f[1] = 1;
              }
              for(int i = 2; i < n + 1; i++){
                  f[i] = f[i - 1] + f[i - 2];
              }
      
              // for(int i = 0; i < n + 1; i++){
              //     cout<<"f[" << i << "]=" << f[i] << endl;
              // }
      
              return f[n];
      
          }
      };
      

6. 1137. 第 N 个泰波那契数

   1. 题目链接：https://leetcode-cn.com/problems/n-th-tribonacci-number/

   2. 思路：根据题目中数学公式进行运算

   3. 代码：

      class Solution {
      public:
          int tribonacci(int n) {
              int f[38] = {0, 1, 1};
              for(int i = 3; i <= n; i++){
                  f[i] = f[i - 3] + f[i - 1] + f[i - 2];
              }
              return f[n];
      
      
          }
      };
      

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

   1. 题目链接：https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k/

   2. 思路：

      • 第一个循环用来判断找数组的第一个数，第二个循环找符合条件的第二个数,时间复杂度为$O(n^2)$
      • 使用哈希表，从最后一个开始遍历，如果哈希表里有这个数，这个数对应的值就加一，如果没有这个数，就把这个数加进哈希表,从哈希表里找与他差为k的数，如果找到了，cnt += m[mid] ,找不到就进行继续往下进行

   3. 代码：

      思路一代码：

      class Solution {
      public:
          int countKDifference(vector& nums, int k) {
              int cnt = 0;
              for(int i = 0; i < nums.size() ; i++){
                  for(int j = i + 1; j < nums.size(); j++){
                      int mid = nums[i] - nums[j];
                      if(mid < 0) mid *= -1;
                      if(mid == k) cnt++;
                  }
              }
      
              return cnt;
      
          }
      };
      

      • 思路二代码

        class Solution {
        public:
            int countKDifference(vector& nums, int k) {
                unordered_map m;
                int cnt = 0;
                for(int i = nums.size() - 1; i >= 0 ; i--){
                    m[nums[i]]++;
                    int mid1 = nums[i] - k;
                    int mid2 = nums[i] + k;
                    if(mid1 > 0 && m.find(mid1) != m.end()) cnt += m[mid1];
                    if(m.find(mid2) != m.end()) cnt += m[mid2];
                }
        
                return cnt;
        
            }
        };
        

8. LCP 01. 猜数字

   1. 题目链接：https://leetcode-cn.com/problems/guess-numbers/

   2. 思路：就枚举判断就行

   3. 代码：

      class Solution {
      public:
          int game(vector& guess, vector& answer) {
              int cnt = 0;
              for(int i = 0; i < 3; i++){
                  if(guess[i] == answer[i]){
                      cnt++;
                  }
              }
              return cnt;
      
          }
      };
      

9. LCP 06. 拿硬币

   1. 题目链接：https://leetcode-cn.com/problems/na-ying-bi/

   2. 思路：只需要判断这一堆币的个数是否是2的倍数，如果不是，就加一强行把他变成2的倍数

   3. 代码：

      class Solution {
      public:
          int minCount(vector& coins) {
              int cnt = 0;
              for(int i = 0; i < coins.size(); i++){
                  if(coins[i] % 2 == 1) coins[i] += 1;
                  cnt += (coins[i] / 2);
              }
              return cnt;
          }
      };
      

10. 剑指 Offer II 069. 山峰数组的顶部

    1. 题目链接：https://leetcode-cn.com/problems/B1IidL/

    2. 思路：找到最大的数字就行

    3. 代码：

       class Solution {
       public:
           int peakIndexInMountainArray(vector& arr) {
               int max = 0;
               int index = -1;
               for(int i = 0; i < arr.size(); i++){
                   if(arr[i] > max) {
                       max = arr[i];
                       index = i;
                   }
                   if(arr[i] < max) break;
               }
       
               return index;
       
           }
       };
       

今日收获

1. 一维数组的运用

今日疑问：

1. 二分查找的细节问题

资料链接

1. https://blog.csdn.net/songyaxuanwoai/article/details/123833818?spm=1001.2014.3001.5502

博客链接