数组相关的算法题

最新推荐文章于 2022-05-31 22:42:51 发布
最新推荐文章于 2022-05-31 22:42:51 发布
阅读量364 收藏
点赞数
分类专栏： 编程基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rover2002/article/details/107753670
版权

内容包括：

  • 子数组和最大的最小子集、子数组和>=定值的最小子集、数组的主元素、连续子数组的最大和、
  • 一个无序数组的中位数、两个有序数组的中位数、
  • 数组的平衡点(两边的和相等)、数组的分裂点(左边的数都<=它，右边的数都>=它)、
  • 两个数组(有序或无序两种)的对称差集、两个有序数组的交集；
  • 最长上升子序列，三种元素排序；
  • 待补充的其他问题。

C++语言描述。


// 快速排序
void quickSort(int a[], int left, int right)
{
  if(left < right)
  {
    int i = left, j = right;
    int x = a[left];
    while(i < j)
    {
      while(i < j && a[j] >= x)
        --j;
      if(i < j) a[i++] = a[j];
      while(i < j && a[i] < x)
        ++i;
      if(i < j) a[j--] = a[i];
    }
    a[i] = x;
    quickSort(a, left, i - 1);
    quickSort(a, i + 1, right);
  }
}

/* LintCode-761: 数组和的最小子集
 * 问题：非负整数数组. 取数组中的一部分元素, 使得它们的和大于数组中其余元素的和, 
 * 求出满足条件的元素数量最小值。
 * 给出 nums = [3, 1, 7, 1], 返回 1
 * 给出 nums = [2, 1, 2], 返回 2
 */
int minElement(vector<int>& arr){
  sort(arr.begin(), arr.end());
  int sum = 0;
  for (int i = 0; i < arr.size(); i++)
  {
    sum += arr[i];
  }
  sum = sum/2 + 1;
  int cnt = 0;
  for (int i = arr.size()-1; i >= 0 ; --i)
  {
    sum -= arr[i];
    ++cnt;
    if(sum <= 0) return cnt;
  }
}

/*
 * 求最短子数组的大小，要求子数组的和>=s。
 * Minimum Size Subarray sum
 * For example, given the array [2,3,1,2,4,3,2,2] and s = 7, Output: 2,
 * the subarray [4,3] has the minimal length, [3,2,2] dose Not.
*/
int minSumSize(vector<int>& nums, int s)
{
  // sum是滑动窗口的和，start是窗口的起始位置
  int ret = INT_MAX, sum = 0, start = 0;
  for(int i = 0; i < nums.size(); ++i)
  {
    sum += nums[i];
    while(start <= i && sum >=s)
    {
      // 记录最短长度
      ret = min(ret, i - start + 1);
      // 窗口右移
      sum -= nums[start++];
    }
  }
  return ret == INT_MAX ? -1 : ret;
}

/* LeeCode-168 Majority Element
 * 给定一个大小为n的数组，找出主元素。主元素就是出现次数大于floor(n/2)次的元素。
 * 你可以假设数组是非空的，并且主元素始终存在于数组中。
 * Input: [2,2,1,1,1,2,2] 返回：2
*/
int majorityElement(vector<int>& arr) {
  int ret = 0, cnt = 0;
  for (int num : arr) {
    if (0 == cnt) { //记录当前num
      ret = num;
      ++cnt;
    } else if( num == ret) { //遇到同一个数
      ++cnt;
    } else {
      --cnt;
    }
  }
  return ret;
}
//进阶问题，出现次数大于floor(n/3)的所有元素。
// Input: [1,1,1,3,3,2,2,2] Output: [1,2]
// 摩尔投票法 Moore Voting
vector<int> majorElement(vector<int>& nums)
{
  vector<int> ret;
  int a = 0, b = 0, cnt1 = 0, cnt2 = 0;
  for(int num : nums) {
    if(num == a) {
      ++cnt1;
    } else if(num == b) {
      ++cnt2;
    } else if(cnt1 == 0) {
      a = num; cnt1 = 1;
    } else if(cnt2 == 0) {
      b = num; cnt2 = 1;
    } else {
      --cnt1; --cnt2;
    }
  }
  cnt1 = cnt2 = 0;
  for (int num : nums) {
    if(num == a) ++cnt1;
    else if(num == b) ++cnt2;
  }
  if(cnt1 > nums.size()/3) ret.push_back(a);
  if(cnt2 > nums.size()/3) ret.push_back(b);
  return ret;
}

/*
 * 连续子数组的最大和，返回和。
 * Input: [-2,1,-3,4,-1,2,1,-5,4] Output: 6 
 * 最大和的子数组是[4,-1,2,1]
*/
int maxSubSum(vector<int>& nums)
{
  int retSum = INT_MIN, curSum = 0;
  for(int i = 0; i < nums.size(); ++i) {
    if(curSum <= 0) {
      curSum = nums[i];
    } else {
      curSum += nums[i];
    }
    if(curSum > retSum) {
      retSum = curSum;
    }
  }
  return retSum;
}

/*
 * 求无序数组的中位数，复杂度要求<=O(N*logN)
*/
int partSort(int a[], int start, int end)
{
  int left = start;
  int right = end;
  int key = a[end];
  while(left < right)
  {
    while(a[left] <= key && left < right) ++left;
    while(a[right] >= key && left < right) --right;
    if(left < right)
      swap(a[left], a[right]);
  }
  swap(a[right], a[end]);
  return left;
}
int getMedian(int a[], int len)
{
  int start = 0;
  int end = len - 1;
  // 不论len是奇偶数，mid都用 len/2 ；
  int mid = len / 2; //注意不是 (len-1)/2
  int part = partSort(a, start, end);
  while(part != mid)
  {
    if(part > mid)
      part = partSort(a, start, part - 1);
    else
      part = partSort(a, part + 1, end);
  }
  return a[mid];//注意不是mid+1
}

/*
 * 求两个有序数组的中位数，复杂度要求O(log(m+n))。
 * nums1 = [1, 2], nums2 = [3, 4]; The median is (2 + 3)/2 = 2.5
 * nums1 = [1, 3], nums2 = [2]; The median is 2.0
*/
// k in {(m+n+1)/2, (m+n+2)/2}
int findKth(vector<int>& nums1, int i, vector<int>& nums2, int j, int k)
{
  if(i > nums1.size()) {
    //在nums2中找到从j开始的第k个数
    return nums2[j+k-1];
  }
  if(j > nums2.size()) {
    return nums1[i+k-1];
  }
  if(1 == k) {
    return min(nums1[i], num2[j]);
  }
  // 若剩余大小不足k/2，则从另一个数组中取第k/2个数
  int mid_a = (i + k/2 -1 < nums1.size()) ? nums1[i + k/2 -1] : INT_MAX;
  int mid_b = (j + k/2 -1 < nums2.size()) ? nums2[j + k/2 -1] : INT_MAX;
  if(mid_a < mid_b)
  {
    return findKth(nums1, i + k/2, num2, j, k - k/2);
  } else {
    return findKth(nums1, i, num2, j + k/2, k - k/2);
  }
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    int m = nums1.size(), n = nums2.size(), left = (m + n + 1) / 2, right = (m + n + 2) / 2;
    return (findKth(nums1, 0, nums2, 0, left) + findKth(nums1, 0, nums2, 0, right)) / 2.0;
}
/*
[解释如下：](https://www.cnblogs.com/grandyang/p/4465932.html)

假设两个有序数组的长度分别为m和n，由于两个数组长度之和 m+n 的奇偶不确定，因此需要分情况来讨论，对于奇数的情况，直接找到最中间的数即可，偶数的话需要求最中间两个数的平均值。使用一个小trick:
分别找第 (m+n+1) / 2 个，和 (m+n+2) / 2 个，然后求其平均值即可，这对奇偶数均适用。若 m+n 为偶数的话，取这两个数的平均值；若 m+n 为奇数的话，那么其实 (m+n+1) / 2 和 (m+n+2) / 2 的值相等，相当于两个相同的数字相加再除以2，还是其本身。

这里需要定义一个函数来在两个有序数组中找到第K个元素。K 就是(m+n+1) / 2 或者(m+n+2) / 2。

使用两个变量i和j分别来标记数组 nums1 和 nums2 的起始位置。先考虑边界情况：
1，当某一个数组的起始位置大于等于其数组长度时，说明其所有数组均已经查找过了，只需要直接在另一个数组中找从i或j开始的第k个数就可以了。
2，当K=1的时候，变成分别查找第1个数，只要比较 nums1 和 nums2 的起始位置i和j上的数字，然后直接返回。

难点就在于一般的情况怎么处理，因为需要在两个有序数组中找到第K个元素。
为了加快搜索的速度，可以使用二分法，分别在 nums1 和 nums2 中查找第 K/2 个元素。
先 check 一下，数组中到底存不存在第 K/2 个数字，如果存在就取出来，否则就赋值上一个整型最大值，因为目的是要在 nums1 或者 nums2 中先淘汰 K/2 个较小的数字，判断的依据就是看 midVal1 和 midVal2 谁更小，但如果某个数组的个数都不到 K/2 个，就将其对应的 midVal 值设为整型最大值，表示不从这个数组淘汰出去。
*/

//---------------------------------

/*
 * 寻找数组的平衡点问题
 * 平衡点：比如int numbers[]={1,3,5,7,8,25,4,20}; 
 * 25前面的总和为24，25后面的总和也是24，25这个点就是平衡点。
 * O(2n)算法如下：
*/
int findBalance(int arr[], int len)
{
  long sumLeft = 0;
  long sumRight = 0;
  for(int i=1; i < len; ++i)
  {
    sumRight += arr[i];
  }
  for(int j = 1; j < len; ++j)
  {
    sumLeft += arr[j-1];
    sumRight -= arr[j];
    if(sumLeft == sumRight)
      return j;
  }
  return -1;
}

/*
 * 在数组里查找这样的数，其左边的数都小于等于它，右边的数都大于等于它。
 * 使用额外数组，比如rightMin[]，来帮我们记录原始数组array[i]右边（包括自己）的最小值。
 * 假如原始数组为： array[] = {7, 10, 2, 6, 19, 22, 32}， 那么rightMin[] = {2, 2, 2, 6, 19, 22, 32}. 
 * 从头开始遍历原始数组时，我们保存一个当前最大值 max， 如果当前最大值刚好等于rightMin[i]，
 * 那么这个最大值即为所求。
 * 例如数组 {7, 10, 2, 6, 19, 22, 32} 返回19；
 *     数组 {1,3,5,7,8,25,4,20}，返回第二个数3.
*/
int smallLarge(int data[], int len)
{
  if(data == NULL || len < 1) return -1;
  
  std::vector<int> rightMin(len);
  
  rightMin[len-1] = data[len-1];
  for(int i = len - 2; i >= 0; --i)
  {
    rightMin[i] = min(data[i], rightMin[i+1]);
  }
  
  int leftMax = data[0];
  for(int i = 1; i < len; ++i)
  {
    // [0, i]的最小值
    leftMax = max(data[i], leftMax);
    if(leftMax == rightMin[i])
    {
        return data[i];
    }
  }
  
  return -1;
}

// 求两个数组的对称差集，即只在其中一个数组中出现过的数字组成的集合。
// C++ STL库函数：std::set_symmetric_difference()
// 例如 {1, 3, 5, 7, 9, 11} 和 {1, 1, 2, 3, 5, 8, 13}
// 它们的差集是：{2, 7, 8, 9, 11, 13}
// 两个无序数组的差集：互相二分查找，复杂度为 m*log(n) + n*log(m)。
vector<int> vec_diff_1(vector<int>& vm, vector<int>& vn)
{
    vector<int> vec_ret;
    for(int i = 0; i < vm.size(); i++)
    {
        if(0 == std::binary_search(vn.begin(), vn.begin()+vn.size(), vm[i]))
        {
            vec_ret.push_back(vm[i]);
        }
    }
    for(int i = 0; i < vn.size(); i++)
    {
        if(0 == std::binary_search(vm.begin(), vm.begin()+vm.size(), vn[i]))
        {
            vec_ret.push_back(vn[i]);
        }
    }
    // 对结果排序，可以省略
    sort(vec_ret.begin(), vec_ret.end());
    
    return vec_ret;
}
// 两个有序数组的差集：复杂度O(m+n)
// 事先排序两个数组复杂度：mlog(m)+nlog(n)
vector<int> vec_diff_2(vector<int>& vm, vector<int>& vn)
{
    vector<int> result;
    int first_m=0, first_n=0;
    int last_m = vm.size();
    int last_n = vn.size();
    while(first_m != last_m && first_n != last_n)
    {
        if(vm[first_m] < vn[first_n])
        {
            result.push_back(vm[first_m]);
            ++first_m;
        }
        else if(vn[first_n] < vm[first_m])
        {
            result.push_back(vn[first_n]);
            ++first_n;
        }
        else {
            ++first_m;
            ++first_n;
        }
    }
    
    copy(vm.begin()+first_m, vm.end(), std::inserter(result, result.begin()+result.size()));
    
    copy(vn.begin()+first_n, vn.end(), std::inserter(result, result.begin()+result.size()));
    
    return result;
}

// 求两个数组的交集
// 例如 {1, 3, 5, 7, 9, 11} 和 {1, 1, 2, 3, 5, 8, 13}
// 它们的交集是：{1,3,5}
vector<int> vec_intersection(vector<int>& vm, vector<int>& vn)
{
    vector<int> result;
    int first_m=0, first_n=0;
    int last_m = vm.size();
    int last_n = vn.size();
    while(first_m != last_m && first_n != last_n)
    {
        if(vm[first_m] < vn[first_n])
        {
            ++first_m;
        }
        else if(vn[first_n] < vm[first_m])
        {
            ++first_n;
        }
        else {    //  vm[first_m] == vn[first_n]
            result.push_back(vm[first_m]);
            ++first_m;
            ++first_n;
        }
    }
    return result;
}

/*
 * 最长上升子序列
 * 例如[10,9,2,5,3,7,20,18] 返回4，[2,3,7,20]或者[2,3,7,18]
*/
int maxIncSeq(vector<int>& nums)
{
  vector<int> vbuf;
  for(int i = 0; i < nums.size(); ++i)
  {
    //找到第一个>=当前值的位置
    vector<int>::iterator it = lower_bound(vbuf.begin(), vbuf.end(), nums[i]);
    if(it == vbuf.end())
      vbuf.push_back(nums[i]);
    else
      *it = nums[i];
  }
  return vbuf.size();
}
// 下面这种写法也行：
int maxIncSub(int arr[], int n)
{
  int len = 0;
  int* buf = new int[n+1];
  for(int i = 0; i < n; i++)
  {
    // 二分查找第一个>=当前值的位置
    int pos = lower_bound(buf, buf+len, arr[i]) - buf;
    if(pos == len) {
      buf[len++] = arr[i];
    }
    else {
      buf[pos] = arr[i];
    }
  }
  delete[] buf;
  
  return len;
}

//三种颜色排序问题
void sort_colors(int[] colors, int len)
{
  int left = 0, right = len - 1;
  int cur = 0;
  while(cur <= right)
  {
    if(colors[cur] == 0)
    {
      swap(colors[cur],colors[left]);
      left++;
      cur++;
    }
    else if(colors[cur] == 2)
    {
      swap(colors[cur], colors[right]);
      right--;
    }
    else // if(colors[cur] == 1)
    {
      cur++;
    }
  }
}

未完待续。

Rover Ramble
关注
专栏目录
Java—数组中涉及的常见算法
小贺想改变
09-04 765
数组元素的赋值(杨辉三角、回形数等)，求数值型数组中元素的最大值、最小值、平均数、总和等，数组的复制、反转、查找(线性查找、二分法查找)，数组元素的排序算法
基础算法题-数组相关
manu_zhang的博客
05-21 371
1. 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 如果直接排序，后进行选择，则时间复杂度最优为O(nlogn)，这里有两种思路。 第一种，利用快速排序的思想，找到第n/2位置的数。然后扫描数组，确保这个数的确超过数组长度的一半。 第二种，设置两个标记，一个记录值，一个记录次数，当后一个与前一个不同时，记录数减一，当记录数减少到0时候，需要更改值的标记。 时间复杂度都为O
与数组相关算法
wudiyong22的专栏
08-12 3296
找出递增数组中和为s的两个数 问题： 已知一个递增排序的数组和一个数字s，在数组中找出两个数，使它们的和正好等于s，找出任意一对便可。 思路： 普通解法： 第一个数从数组的开头开始，然后利用二分法找第二个数，时间复杂度为nlogn，因为第一个数是从头到尾顺序选择的。 时间复杂度为n的解法： 第一个数从数组的开头开始，第二个数从数组的结尾开始，如果两者的和大于s，则第二个数往前取下一个
数组的相关算法题
comli_cn的博客
07-31 345
1. 螺旋矩阵 描述： 给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。 示例: 输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ] 解题思路： 模拟螺旋矩阵的生成方式，即先按照顺序在第一行从左到右生成，然后在最后一列从上到下生成，然后在最后一列从右到左生成，然后在第一列从下到上生成，彼此之间不能有交叉。但这样只能生成最外层的数，要想完整地生成矩阵我们可以每生成一整行或者一整列就把这一整行或一整列去掉，只对
【Java】数组的相关算法（数组反转、复制、查找、排序、找最值、数组统计）
渐若窥宏大的博客
05-16 529
数组的相关算法 文章目录数组的相关算法1、数组找最值2、 数组统计：求总和、均值、统计偶数个数等3、 反转4、 复制5、 查找6、 排序 数组的算法： 1、找最值 2、找最值及其下标 3、统计：累加和、平均值等 4、反转 5、复制 6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标 （1）数组中的元素是无序的(顺序查找) （2）数组中的元素是有序的(二分查找) 复习下数组的 public class Test01_Review{ public static void main(String
数组相关算法题
业精于勤荒于嬉 行成于思毁于随
04-06 222
题一： 128.：Longest Consecutive Sequence 要求是O（n），所以不能使用排序，那么就得考虑辅助。利用Map，key为num，value为其连续长度，每次之更新这个连续序列的首尾两个位置的value值。 public int longestConsecutive(int[] nums) { Map&amp;amp;amp;amp;amp;lt;Integer, Intege...
数组相关算法题汇总
qq_43103261的博客
01-05 1504
在属于数组考点系列的题目中，划分为四个常考问题：子数组问题、矩阵问题、O(n)类型问题和思维转换类型问题。 子数组问题：就是给定一个数组，围绕该数组的子数组列出诸多难题，等待我们来解答。 矩阵问题：给定一个矩阵（或者称为二维数组），围绕该矩阵列出不同方式遍历矩阵中元素等难题，等待我们来解答。 O(n)类型问题：O(n)是指时间复杂度为O(n)，给定的题目题意一般很容易理解，其一般解法（俗称暴力解法，时间复杂度一般为O(n^2)，甚至更高）也很简单，但是题目要求你的解法时间复杂度为O(n)。看到这些题目
C#实现的二维数组排序算法示例
08-28
本文主要介绍了C#语言实现的二维数组排序算法，涉及C#针对二维数组的遍历、判断、排序等相关操作技巧。本算法实现了对二维数组的排序，能够根据指定的列索引和排序类型对二维数组进行排序。 知识点1：二维数组的...
java算法题 : 数组相关问题
03-14
在处理算法题，特别是数组相关的问题时，了解并熟练掌握数组的特性、操作以及与其相关的算法是至关重要的。本篇将深入探讨Java中的数组及其在算法中的应用。 一、数组的定义与初始化 在Java中，数组可以被声明为...
C++后端数组存储算法 编译正确 C++
最新发布
07-23
原题解析：见算法训练营 P65~66 */ #include using namespace std; string a[5000],b[5000],c[5000]; int main() { int a1,b1,c1,flag=0; cin>>a1>>b1>>c1; for(int i=1; i; i++) cin>>a[i]; for(int i=1; i; i...
Java语言的一维数组，二维数组，案例习题，算法
07-17
Java语言的一维数组，二维数组，案例习题，算法
数组相关算法题（一）
ym563099457的博客
05-18 3386
数组相关算法题： 1 二分查找 给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 ...
与数组相关的算法题
Zha_yc的博客
12-21 197
一维数组空间是连续的，二维地址空间是多个连续的地址空间组成。因为其连续性，导致其不能随便删除元素，只能覆盖。数组类型的题目多出二分查找，双指针，滑动窗口，模拟行为等。 ​​​​​​​​​​​​​​​​​​​​1. 二分查找 1.1 思路 二分查找关键点在于对于区间的定义。主要有两种方式：左闭右闭、左闭右开。 在刷题过程中默认使用左闭右闭的方式，在这个过程中需要注意两点： right = nums.size() - 1 if(nums[middle] > target){ ri.
数组常见算法题
weixin_34150830的博客
11-25 603
 数组常见算法题     连续子数组的最大和 问题描述： 输入一个整型数组，数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和，求所有子数组和的最大值。例如输入的数组为1,-2,3,10,-4,7,2,-5，和最大的子数组为3,10,-4,7,2，因此输出为该子数组的和18。 int max_sub(int a[], int size) { int i;...
数组及其相应算法
lbj12345678_的博客
05-31 306
文章只是为了方便自己总结刷题，参考代码随想录，指路：https://programmercarl.com
数组相关算法
mango660的博客
02-05 152
二维数组周边元素输出 如图，输出周边元素（上图里边的数字表示的是下标） 思路分析： 首先思考周边元素的下标有什么特殊之处 然后就是写代码呀。（不然你还想看什么，再没什么需要分析了，各位宝宝） 忘说了：特殊自处见代码注释！ #include <stdio.h> int main(void) { int m, n; // m 行 n 列 scanf("%d %d", &amp...
数组操作相关算法
06-16 236
/* 数组的相关的算法操作： 1、在数组中找最大值/最小值 */ class Test11_FindMax{ public static void main(String[] args){ int[] array = {4,2,6,8,1}; //在数组中找最大...
Leetcode练题系列(一): 数组相关的算法
BoomMan
01-04 471
LeetCode 数组相关算法
C语言数组详解与试题解析
本章内容主要围绕数值数组、字符数组、一维数组、二维数组、字符数组实现的字符串以及相关的指针数组进行展开。数组的定义、初始化、元素引用以及在实际问题中的应用是学习的核心。 一、数组的定义和初始化 1. 一维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值