常见的数组问题

最新推荐文章于 2023-10-22 23:02:28 发布
最新推荐文章于 2023-10-22 23:02:28 发布
阅读量2.4k 收藏 5
点赞数
分类专栏： linux C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenchao126/article/details/8077706
版权
linux 同时被 2 个专栏收录
38 篇文章 0 订阅
订阅专栏
C/C++
22 篇文章 0 订阅
订阅专栏

1、给定一个含有n个元素的整型数组a，求a中所有元素的和。（要求采用递归的方式，一行代码）

  参考答案：

#include<stdio.h>

int sum(int* a,int n);

int main()
{
    int array[5] = {1,2,3,4,5};
    int summer;
    summer = sum(array,sizeof(array)/sizeof(array[0]));
    printf("sum %d\n",summer);

    return 0;
}

int sum(int* a,int n)
{
    return n == 0 ? 0 : sum(a,n-1) + a[n-1];
}
2、给定一个含有n个元素的整型数组a，找出其中的最大值和最小值

本题如果你能用分治法来求解的话，就比单纯的采用遍历法高一阶了

#include<stdio.h>

#define N 5

int get_minvalue(int* a,int n);
int get_maxvalue(int* a,int n);
int get_min_max(int* a,int n,int* min,int* max);

void MaxandMin(int *a, int l, int r, int* maxValue, int* minValue);

int main()
{
    int array[N] = {3,6,9,1,6};
    int min,max;

    min = get_minvalue(array,N);
    max = get_maxvalue(array,N);

    printf("min value %d,max value %d\n",min,max);

    get_min_max(array,N,&min,&max);
    printf("min value %d,max value %d\n",min,max);
    
    MaxandMin(array,0,N-1,&max,&min);
    printf("min value %d,max value %d\n",min,max);

    return 0;
}

int get_min_max(int* a,int n,int* min,int* max)
{
    int i;
    *min = *max = a[0];
    
    for(i = 1; i < n; i++)
    {
        if(*min > a[i]) *min = a[i];
        if(*max < a[i]) *max = a[i];
    }

    return 0;
}

int get_minvalue(int* a,int n)
{
    int minvalue = a[0];
    int i;
   
    for(i = 1; i < n; i++)
    {
        if(a[i] < minvalue) minvalue = a[i];
    }

    return minvalue;
}

int get_maxvalue(int* a,int n)
{
    int maxvalue = a[0];
    int i;
   
    for(i = 1; i < n; i++)
    {
        if(a[i] > maxvalue) maxvalue = a[i];
    }

    return maxvalue;
}

void MaxandMin(int *a, int l, int r, int* maxValue, int* minValue)
{ 
        if(l == r) 
        { 
                *maxValue = a[l] ; 
                *minValue = a[l] ; 
                return ; 
        } 
        if(l + 1 == r)
        { 
                if(a[l] >= a[r]) 
                { 
                        *maxValue = a[l] ; *minValue = a[r] ; 
                } 
                else { *maxValue = a[r] ; *minValue = a[l] ; } 
                return ; 
        } 
        int m = (l + r) / 2 ; 
        int lmax ; int lmin ; int rmax ; int rmin ;  
        MaxandMin(a, l, m, &lmax, &lmin); 
        MaxandMin(a, m + 1, r, &rmax, &rmin); 
        *maxValue = lmax > rmax ?lmax:rmax; 
        *minValue = lmin < rmin ?lmin:rmin;
}

3、给定一个含有n个元素的整型数组，求其最大值和次大值

       本以为和上面最大值和最小值的方法一样，不同之处只是取最大和次大的区别，但是在测试的时候遇到问题，比如对l == r的处理，如果相同则最大和次大是同一数，如下列的数组，有一组就会是lmax = lsec = 9;而9是最大的数，结果就是最大和次大都是9，所以须要解决这个问题，第一，如果只有一个数的数组，那么最大和次大都是同一数，这没有问题；第二，如果数组大小不是1，那么如果遇到 l == r的情况时，我们就设定为int的最小值INT_MIN，这样就可以解决上面遇到的问题了。

#include<stdio.h>
#include<limits.h>
 #define N 5
//#define N 1

int get_max_sec(int* a,int l,int r,int* max,int* sec);

int main()
{
    int array[N] = {3,6,9,1,5};
    //int array[N] = {3};
    int max,sec;

    get_max_sec(array,0,N-1,&max,&sec);
    printf("max value %d,second value %d\n",max,sec);
    
    return 0;
}

int get_max_sec(int* a,int l,int r,int* max,int* sec)
{
    if(l == r)
    {
        if(r == 0)
        {
            *max = *sec = a[l];
        }
        else
        {
            *max = a[l];
            *sec = INT_MIN;
        }
        return 0;
    }  
    
    if(l + 1 == r)
    {
        if(a[l] >= a[r])
        {
            *max = a[l];
            *sec = a[r];
        }
        else
        {
            *max = a[r];
            *sec = a[l];
        }
        //*max = a[l] >= a[r] ? a[l] : a[r];
        //*sec = a[l] >= a[r] ? a[r] : a[l];
        return 0;
    }

    int mid = (l + r)/2;
    int lmax,lsec,rmax,rsec;
    get_max_sec(a,l,mid,&lmax,&lsec);
    get_max_sec(a,mid + 1,r,&rmax,&rsec);

printf("lmax %d lsec %d rmax %d rsec %d\n",lmax,lsec,rmax,rsec);

    if(lmax > rmax)
    {
        *max = lmax;
        *sec = lsec > rmax ? lsec : rmax; 
    }
    else if(lmax < rmax)
    {
        *max = rmax;
        *sec = rsec > lmax ? rsec : lmax;
    }

    return 0;
}


4、求数组中出现次数超过一半的元素（另一种说法是：给定一个n个整型元素的数组a，其中有一个元素出现次数超过n / 2，求这个元素。）

      我们可以想象一下，n个整形元素的数组，超过n/2个元素是相同的，无论如果排序，至少有3个元素是相邻的。网上提供了两种方法，一，先排序，取中间元素即可，如果你能选择一些牛叉的排序方法，你可以加分；二，计数，从前往后，如果值相同则+1，否则-1，如果计数小于0，则清空，再开始，直到最后，剩下的那个就是要找的元素了。

排序的方法以后单独开个板块，这里只是看看第二种方法。

#include<stdio.h>

#define N 10

int find_data(int*a ,int n,int* data);

int main()
{
    int array[N] = {1,2,1,2,4,2,2,2,4,2};
    int data;

    find_data(array,N,&data);

    printf("the value is %d\n",data);
   
    return 0;
}

/* 计数的方法查找元素 */
int find_data(int* a,int n,int* data)
{
    int curr_value;
    int count;
    int i;

    curr_value = a[0];
    count = 1;

    for(i = 1; i < N;i++)
    {
        if(curr_value == a[i]) count++;
        else 
        {
            count--;
            if(count < 0)
            {
                curr_value = a[i];
                count = 1;
            }
        }
    }

    *data = curr_value;    

    return 0;
}

5、给定一个含有n个元素的整型数组，找出数组中的两个元素x和y使得abs(x - y)值最小（求数组中元素的最短距离）

     使两个数的绝对值最小，当然是先排序，然后看看那两个相邻元素之间的绝对值最小了

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>

#define N 5

int compare(const void* a,const void* b);
int find_abs_min(int* a,int n);

int main()
{
    int array[N] = {0,2,1,9,4};

    find_abs_min(array,N);

    return 0;
}

int compare(const void* a,const void* b)
{
    return *(int*)a - *(int*)b ;
}

int find_abs_min(int* a,int n)
{
    int i;
    int min_value,j,k;

    qsort(a,n,sizeof(int),compare);

    min_value = INT_MAX;
    j = k = 0;
    for(i = 0;i < n - 1;i++)
    {
        if(a[i+1] - a[i] < min_value)
        {
            min_value = a[i+1] - a[i];
            j = a[i+1];
            k = a[i];
        }
    }

    printf("min_value %d,%d - %d\n",min_value,j,k);

    return 0;
}

6、给定两个含有n个元素的有序（非降序）整型数组a和b，求出其共同元素

参考答案 

#include<stdio.h>

#define N 5
int find_comm(int* a,int* b,int n);

int main()
{
    int a[N] = {0,1,2,3,4};
    int b[N] = {1,3,5,7,9};

    find_comm(a,b,N); 

    return 0;
}

int find_comm(int* a,int* b,int n)
{
    int i = 0, j = 0;
    while(i < n && j< n)
    {
        if(a[i] < b[j]) i++;
        else if(a[i] == b[j])
        {
            printf("comm value is %d\n",a[i]);
            i++;
            j++;
        }
        else j++;
    }
    return 0;
}

7、给定三个含有n个元素的整型数组a,b和c，求他们最小的共同元素
      下面的参考答案给出的是三个数组所有相同元素，其第一个就是最小的共同元素。

#include<stdio.h>

#define AN 5
#define BN 6
#define CN 4

int compare(const void* a,const void* b);
int find_min_comm(int* a,int* b,int* c,int an,int bn,int cn);

int main()
{
    int a[AN] = {2,3,6,4,7};
    int b[BN] = {3,7,9,2,1,5};
    int c[CN] = {1,3,5,2};

    find_min_comm(a,b,c,AN,BN,CN);

    return 0;
}


int compare(const void* a,const void* b)
{
    return *(int*)a - *(int*)b;
}

int find_min_comm(int* a,int* b,int* c,int an,int bn,int cn)
{
    int i,j,k;

    qsort(a,an,sizeof(int),compare);
    qsort(b,bn,sizeof(int),compare);
    qsort(c,cn,sizeof(int),compare);

    i = j = k = 0;
    while(i < an && j < bn && k < cn)
    {
        if(a[i] < b[j]) i++;
        else
        {
            if(b[j] > c[k]) k++;
            else if(b[j] < c[k]) j++;
            else
            {
                if(a[i] == b[j])
                {
                    printf("comm %d\n",a[i]);
                    //break;
                    i++;j++;k++;
                }
                else
                {
                    j++;k++;
                }

            }
        }

    }

    return 0;
}









wenchao126
关注
专栏目录
算法分析之数组问题
小朱小朱绝不认输的博客
11-30 2618
文章目录一、数组理论基础二、leetcode例题讲解数组问题 一、数组理论基础 数组是非常基础的数据结构。 首先要知道数组在内存中的存储方式：数组是存放在连续内存空间上的相同类型数据的集合。 数组可以方便的通过下标索引的方式获取到下标下对应的数据。 需要两点注意的是： 数组下标都是从0开始的。 数组内存空间的地址是连续的。 正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。 数组的元素是不能删的，只能覆盖。 二维数组在内存的空间地址是连续的么？在Jav
常见数组面试题
11-02
### 常见数组面试题解析 #### 一、数组求和 **题目描述：** 使用递归方式实现数组求和，并且要求整个函数只使用一行代码。 **解答：** ```cpp int sum(int* a, int n) { return n == 0 ? 0 : sum(a, n - 1) + a...
数组的常见问题
Purpleangle4321的博客
04-09 154
Day05_SHJavaTraing_4-8-2017 1.运行时异常：NullPointerException 　　①第一种体现形式　　 1 String[] strs = new String[4]; 2 strs = null; 3 System.out.println(strs[0]); 　　②第二种体现形式（只要是null值，就不能去调用方法或者属性） ...
学习数组常见问题
selints的博客
06-25 648
学习数组
数组常见问题大汇总
lmx9813的博客
10-19 358
四种拷贝都是浅拷贝： （1）for循环; （2）clone; （3）System.arraycopy(src,srcPos,dest,destPos,length)不产生新对象 底层调用native src:源数组 srcPos：源数组要复制的起始位置 dest:目的数组 destPos:目的数组放置的起始位置 length:复制的长度 （4）Arrays....
数组中常见的问题
qq_45528908的博客
08-04 283
数组索引越界异常 原因：编号写错了。 解决办法：修改编号。 eg: int[] array = {1,2,3,4,6}; x=array[5];//索引越界 空指针异常 所有的引用类型变量，都可以赋值为一-个null值。但是代表其中什么都没有。 数组必须进行new初始化才能使用其中的元素。 如果只是赋值了一个null,没有进行new创建, 那么将会发生: 空指针异常NullPointerException 原因:忘了new 解决:补上new ...
常见数组问题及常识
MKP1103042223的博客
04-10 314
1，(ArrayIndexOutOfBoundsException)---数组脚标越界异常，表示访问到不存在的角标；例如：int[] arr = new int[2];System.out.println(arr[3]);2，NullPointerException----表示arr 引用没有指向实体，却在操作实体中的元素时。例如：int[ ] arr = null;System.out.prin...
day05 11 常见问题 数组索引越界异常
08-31
day05_11_常见问题_数组索引越界异常
JavaScript中数组添加值和访问值常见问题
10-22
本文将详细分析JavaScript数组添加值和访问值过程中常见的几个问题。 首先，要向JavaScript数组中添加一个新值，通常使用数组自带的方法，例如push()、unshift()等。push()方法用于在数组的末尾添加一个或多个元素...
C语言常见问题-数组初始化的四种方法.docx
03-12
初始化数组的方式多种多样，以下将详细讲解四种常见的初始化方法。 1. 初始化参数列表 这是最直观的初始化方式，可以直接在声明数组时为其赋值。对于整型数组，可以指定部分或全部元素的值，未指定的元素会被自动...
异常体系
qq_35701633的博客
09-23 203
RuntimeException（运行时异常）：不需要try...catch...或throws 机制去处理的异常。 非RuntimeException：需要try...catch...或throws 机制去处理的异常。 常见的RuntimeException: ClassCastException NullPointerException ArrayIndexOutOfBound...
数组常见问题
Jian_FH的博客
08-04 332
public class ArrayDemo { public static void main(String[] args) { // TODO Auto-generated method stub //数组的定义 元素类型[] 数组名 = new 元素类型[元素个数或数组长度] double[] arr = n
数组常见相关问题及算法
江韵的博客
10-24 1267
从数组的使用到数组相关排序算法 数组异常原因
关于数组的几道面试题
iteye_6945的博客
03-09 185
http://www.cnblogs.com/graphics/archive/2010/08/24/1761620.html     数组求和 求数组的最大值和最小值 求数组的最大值和次大值 求数组中出现次数超过一半的元素 求数组中元素的最短距离 求两个有序数组的共同元素 求三个数组的共同元素 找出数组中唯一的重复元素 找出出现奇数次的元素 求数组中满足给定和的数对 ...
数组操作的常见问题
weixin_46471817的博客
06-13 298
数组操作的常见问题 (1)ArrayIndexOutOfBoundsException数组索引越界异常，因为访问了不存在的索引。 (2)NullPointerException空指针异常，因为null是指不再指向堆内存的数据，而程序还要访问它。 空常量null是可以复制给引用数据类型的，表示该引用不再指向堆内存的数据。 (3)代码示例： int[] arr = {1,2,3}; System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsExcep
数组(常见问题总结)
qq_35978855的博客
10-23 513
数组(常见问题总结) 数组常见的两个操作问题 1ArrayIndexOutOfBoundsException:数组索引越界异常 2NullPointerException:空指针异常 /** * 数组操作的两个常见小问题 * * ArrayIndexOutOfBoundsException:数组索引越界异常 * 原因:你访问了不存在的索引 * * NullPointerExcept...
数组及常见问题
ztt910的博客
10-22 305
但是有两种情况下数组名取全部元素的地址：第一种为操作符sizeof,在计算空间的时候，取全部元素的地址。如果大括号中的字符个数小于字符数组的长度，则把大括号中的字符赋给数组中前面的元素，其余元素自动赋值为空字符（即‘\0’）。即：char str[6] = {'h','e','l','l','o', '\0'};第一种： char str[10] = {'h','e','l','l','o'};第二种：char str[5] = {'h','e','l','l','o'};相同，系统不会自动添加'\0'。
算法中常见的数组问题
ShellDawn的博客
07-04 557
求数组中，最长上升字串问题： a.连续最长严格上升字串：CF702A求数组中，K组连续M个数之和最大的问题： 前缀和+二维dp：CF467C求数组中，最大和的字串： HDUOJ 1003
c语言中数组的常见问题
最新发布
11-14
C语言中数组的常见问题包括以下几点： 1.如何初始化数组？ 数组可以在定义时进行初始化，也可以在定义后进行初始化。例如： ```c int arr1[5] = {1, 2, 3, 4, 5}; // 定义时初始化 int arr2[5]; // 定义后初始化 arr2[0] = 1; arr2[1] = 2; arr2[2] = 3; arr2[3] = 4; arr2[4] = 5; ``` 2.如何访问数组元素？ 数组元素可以通过下标进行访问，下标从0开始。例如： ```c int arr[5] = {1, 2, 3, 4, 5}; int a = arr[0]; // a的值为1 int b = arr[2]; // b的值为3 ``` 3.如何获取数组长度？ 在C语言中，获取数组长度的方法是通过sizeof运算符获取数组所占用的字节数，然后除以数组中每个元素所占用的字节数。例如： ```c int arr[5] = {1, 2, 3, 4, 5}; int len = sizeof(arr) / sizeof(arr[0]); // len的值为5 ``` 4.如何将数组作为函数参数传递？ 在C语言中，数组作为函数参数传递时，实际上传递的是数组的首地址。例如： ```c void printArray(int arr[], int len) { for (int i = 0; i < len; i++) { printf("%d ", arr[i]); } } int main() { int arr[5] = {1, 2, 3, 4, 5}; int len = sizeof(arr) / sizeof(arr[0]); printArray(arr, len); // 输出：1 2 3 4 5 return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值