【C语言】初阶算法相关习题（一）

个人主页

文章目录

• ⭐一、数字在升序数组中出现的次数
• 🏠二、整数转换
• 🚀三、至少是其他数字两倍的最大数
• 🏝️四、字符个数的统计
• 🎄五、自除数
• 🎡六、除自身以外数组的乘积
• 🎉七、两个数组的交集

  ⭐一、数字在升序数组中出现的次数

  题目描述：数字在升序数组中出现的次数

  

  解题思路：由于数组是升序的，所以我们可以直接采用暴力的方法，遍历数组，统计数组中出现这个数字的次数即可解决。

  代码实现：

  int GetNumberOfK(int* nums, int numsLen, int k ) {
      // write code here
      int i = 0;
      int count = 0;
      for(i=0;i
          if(nums[i] == k)
          {
              count++;
          }
      }
      return count;
  }
  
      int c = A ^ B;
      int count = 0;
      int i = 0;
      for(i=0;i
          if((c & 1) == 1)
          {
              count++;
          }
          c = 1;
      }
      return count;
  }
  

  🚀三、至少是其他数字两倍的最大数

  题目描述：至少是其他数字两倍的最大数

  

  解题思路：

  1.创建一个max变量表示最大值，secondmax表示次大值，m用于记录最大值的下标。

  2.遍历数组，如果当前值大于 max，更新 secondmax 为原来的 max，并将 max 更新为当前值，同时记录最大值的索引m。否则，如果当前值大于 secondmax，更新 secondmax。

  3.遍历结束后，判断 max 是否大于等于 2 × secondmax，并根据条件返回结果。

  代码实现：

  int dominantIndex(int* nums, int numsSize) {
      int max = 0;
      int secondmax = 0;
      //记录最大值的下标
      int m = 0;
      for(int i = 0;i
          if(nums[i]  max)
          {
              secondmax = max;
              max = nums[i];
              m = i;
          }
          else if(nums[i] > secondmax)
          {
              secondmax = nums[i];
          }
      }
      return (max >= (2 * secondmax)) ? m:-1;
  }
  

  🏝️四、字符个数的统计

  题目描述：字符个数的统计

  

  解题思路：

  1.定义一个字符数组 a 用于存储输入的字符串。

  2.定义一个辅助数组 str，大小为 128，用于记录每个字符是否出现过。

  3.使用 strlen函数 获取输入字符串的长度。

  4.遍历输入字符串的每个字符，利用 str 数组记录字符的出现情况，并统计不同字符的数量，统计完后将改位置的值设为1，避免重复计算。

  5.最后输出统计结果即可。

  代码实现：

  #include 
  #include 
  int main() {
      char a[500];
      char str[128] = {0};
      int count = 0;
      scanf("%s",a);
      int len = strlen(a);
      for(int i = 0;i
          if(str[a[i]] == 0)
          {
              count++;
              str[a[i]] = 1;
          }
      }
      printf("%d\n",count);
      return 0;
  }
  
      int tmp,flag;
      tmp = nums;
      while(tmp  0)
      {
          flag = tmp % 10;
          if(flag == 0 || nums % flag != 0)
          {
              return false;
          }
          tmp /= 10;
      }
      return true;
  }
  int* selfDividingNumbers(int left, int right, int* returnSize) {
      int* result = (int*)malloc(sizeof(int) * (right - left + 1));
      int count = 0;
      for(int i = left;i 
          if(jungeNumber(i))
          {
              result[count] = i;
              count++;
          }
      }
      *returnSize = count;
      return result;
  }
  
      int* result = (int*)malloc(sizeof(int) * numsSize);
      *returnSize = numsSize;
      //先乘左边的，再乘右边的
      int left = 1,right = 1;
     for(int i = 0;i
          result[i] = left;
          left *= nums[i];
     }
      for(int i = numsSize - 1;i=0;i--)
      {
          result[i] *= right;
          right *= nums[i];
      }
      return result;
  }
  
      int len = nums1Size  nums2Size ? nums1Size : nums2Size;
      int* result = (int*)malloc(sizeof(int) * len);
      int k = 0;
      for(int i = 0;i
          int flag = 0;
          for(int j = 0;j
              if(nums1[i] == nums2[j])
              {
                  flag = 1;
                  nums2[j] = -1;
              }
          }
          if(flag == 1)
          {
              result[k++] = nums1[i];
          }
      }
      *returnSize = k;
      return result;
  }