精华内容
下载资源
问答
  • 维数组, 二分法查找数组元素下标 快速查找数组最大值 数组作为实参的问题

    1,快速查找最大值和最小值

    # include <stdio.h>
    void main()
    {
    int a[4]  = {12,13,14,15};
    int max = 0,i;
        for(i = 1;i<4;i++)
        {
            if(a[max] < a[i])
            {
                max = i;
            }   
        }
    printf("%d",a[max]);
    getchar();
    }

    2,二分查找

    (输入一个数字,查找是否在数组中存在,有则输出下标,无则输出-1)

    二分查找有一个前提,就是数组是从小到大排列(不嫌别扭的话也可以从大到小)。程序运行的流程,类似于猜数字的游戏,给定一个区间,取中间值,大了则把后面全部排出,小了就把前面的全部排除,搜索范围以每次一半的速度缩小。

    如果我们想把这个东西搞复杂:可以采用随机数,生成一个数组。然后输入任意一个数作为待搜索值,然后将生成的数组进行冒泡排序,最后再进行二分查找。 其实就是尽量把数据从具体的变为抽象的,或者说随机的。

    # include <stdio.h>
    void main()
    {
        int key;
        int a[5] = {1,2,3,4,5};     
        int search(int array[],int len,int key);
        scanf("%d",&key);
        getchar();
        printf("%d",search(a,5,key));
        getchar();
    }
    int search(int array[],int len,int key)
    {
        int start = 0,end = len - 1;
        while(start <= end)
        {
            int mid = (start + end) / 2;
            if(array[mid] == key)
            {
                return mid;
            }else if(array[mid] > key)
            {
                end = mid - 1;      
            }else{
                start = mid + 1;
            }
        }
        return -1;      
    }

    比如现在有一个数组: int a[5] = {1,2,3,4,5}

    数组长度 len = sizeof(a) / sinzof(int) 因为一个int型元素有四个字节,数组长度等于其元素数,也就等于数组的总字节数除以元素的字节数。

    模拟调用: serach(a,5,key); //注意这里的第一个参数直接填就可以了,但是咱函数声明时是 int a[];

    ——————————二维数组———————————–

    1,定义格式
    (1)int a[1][2] 1是行数 2 是列数

    2,一位数组和二维数组中间联系。

    int a[3][4];
    上述代码定义了一个3行4列的数组,共有3×4=12个元素,数组名为a,各元素的取值如下:
    a[0][0], a[0][1], a[0][2], a[0][3]
    a[1][0], a[1][1], a[1][2], a[1][3]
    a[2][0], a[2][1], a[2][2], a[2][3]

    在二维数组中,要定位一个元素,必须给出一维下标和二维下标,就像在一个平面中确定一个点,要知道x坐标和y坐标。例如,a[3][4] 表示a数组第3行第4列的元素。
    二维数组在概念上是二维的,但在内存中地址是连续的,也就是说存储器单元是按一维线性排列的。那么,如何在一维存储器中存放二维数组呢?有两种方式:一种是按行排列, 即放完一行之后顺次放入第二行。另一种是按列排列, 即放完一列之后再顺次放入第二列。
    在C语言中,二维数组是按行排列的。也就是先存放a[0]行,再存放a[1]行,最后存放a[2]行;每行中的四个元素也是依次存放。数组a为int类型,每个元素占用4个字节,整个数组共占用4×(3×4)=48个字节。

    二维数组的初始化:

    二维数组的初始化可以按行分段赋值,也可按行连续赋值。
    例如对数组a[5][3],按行分段赋值可写为:
    int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };

    按行连续赋值可写为(这是二维数组初始化特殊的地方:以一维数组的形式赋值):
    int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85}

    这两种赋初值的结果是完全相同的。

    错误写法示范:

    int a[][] = {}; 错
    inta[][4] = {{1,2,3},{2,3,4}…}; 正确
    参考一维数组错误写法:
    int a[] = {} 错
    int a[] = {3} 对
    int a[1] = {3} 对

    对于二维数组初始化赋值还有以下说明
    1) 可以只对部分元素赋初值,未赋初值的元素自动取0值。例如:

    int a[3][3]={{1},{2},{3}};
    是对每一行的第一列元素赋值,未赋值的元素取0值。 赋值后各元素的值为:
    1 0 0
    2 0 0
    3 0 0

    int a [3][3]={{0,1},{0,0,2},{3}};
    赋值后的元素值为:
    0 1 0
    0 0 2
    3 0 0

    2) 如对全部元素赋初值,则第一维的长度可以不给出。例如:
    int a[3][3]={1,2,3,4,5,6,7,8,9};
    可以写为:
    int a[][3]={1,2,3,4,5,6,7,8,9};

    3) 数组是一种构造类型的数据。二维数组可以看作是由一维数组的嵌套而构成的。设一维数组的每个元素都又是一个数组,就组成了二维数组。当然,前提是各元素类型必须相同。根据这样的分析,一个二维数组也可以分解为多个一维数组。C语言允许这种分解。
    如二维数组a[3][4],可分解为三个一维数组,其数组名分别为:a[0]、a[1]、a[2]。
    对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素,例如:一维数组a[0]的元素为a[0][0], a[0][1], a[0][2], a[0][3]。必须强调的是,a[0], a[1], a[2]不能当作下标变量使用,它们是数组名,不是一个单纯的下标变量。

    下标取值说明:
    数组a[m][n]中,第一个元素是a[0][0],最后一个元素是a[m-1][n-1].

    关于昨日遗留问题解答:数组作为参数调用函数

    首先在函数声明时,形参列表要设置三个值。
    int search(int array[], int len, int key)
    数组类型与名字 数组长度 搜索元素

    延伸–二维数组的传参问题:

    可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以指定所有维数的大小,也可以省略第一维的大小说明,如:

    void Func(int array[3][10]);
    void Func(int array[][10]);
    
    二者都是合法而且等价,但是不能把第二维或者更高维的大小省略,如下面的定义是不合法的:
    
    void Func(int array[][]);
    
    因为从实参传递来的是数组的起始地址,在内存中按数组排列规则存放(按行存放),而并不区分行和列,
    如果在形参中不说明列数,则系统无法决定应为多少行多少列,不能只指定一维而不指定第二维,下面写法是错误的:
    
    void Func(int array[3][]);实参数组维数可以大于形参数组,例如实参数组定义为:
    
    void Func(int array[3][10]);
    
    而形参数组定义为:
    
    int array[5][10];
    
    这时形参数组只取实参数组的一部分,其余部分不起作用。
    

    不用指针的情况下,将二维数组作为实参传参并实现功能,代码很粗糙,贵在其中的规则:

    //二维数组传参时,函数定义时形参列表以及实参传递的形式
    #include<stdio.h>  
    void main()
    {
        void c(int array[3][3]);  //功能函数的声明,注意形参列表的格式
        int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};    //定义二维数组并初始化赋值
        c(a);     //传参调用,主意二维数组作为实参时的写法
        getchar();
    }
    
    void c(int array[3][3])     //功能函数的定义
    {   
        int i,j,max;
        for(i=0;i<3;i++)
        {
            max=array[i][0];
            for(j=1;j<3;j++)
            {
                if(array[i][j]>max)
                {
                    max=array[i][j];
                }
            }
            printf("\n第%d行最大的值是%d:",i+1, max);
         }  
    }
    展开全文
  • 给定个整数n,表示数组的个数,依次读数再进行操作。 (数组从0开始读起) #include <iostream> #include<stdio.h> #include<algorithm> using namespace std; int main() { int a[10]; int...

    给定一个整数n,表示数组的个数,依次读数再进行操作。
    (数组从0开始读起)

    #include <iostream>
    #include<stdio.h>
    #include<algorithm>
    using namespace std;
    
    int main()
    {
    
        int a[10];
        int n;
        cin>>n;
        int maxx=0;
    
        for(int i=0; i<n; i++)
        {
            scanf("%d",&a[i]);
        }
        for(int i=0; i<n; i++)
        {
            if(a[i]>a[maxx])
            {
               maxx=i;
    
    
            }
    
        }
        printf("最大下标:%d\n最大值%d\n",maxx,a[maxx]);
    
        return 0;
    
    }
    
    

    输出样例:
    在这里插入图片描述

    展开全文
  • 题目描述 创建一个5个整数的一维数组,并将每个数组元素赋值为数组下标的平方。输出数组的长度;然后在下一行依次输出每个数组元素的值,元素之间用空格分开,最后一个元素后输出换行。 输入描述 无 输出描述 省略 ...
  • 假设数组为a,长为nint sum = 0;for(int i = 1;i < n; i = i + 2)sum+=a[i];或者:for i=1 to nif i mod 20 thensum=sum+a(i)end ifnext iprint sum扩展...其中,a是一维数组的数组名,该数组有10个元素依次表...

    假设数组为a,长为n

    int sum = 0;

    for(int i = 1;i < n; i = i + 2)

    sum+=a[i];

    或者:

    for i=1 to n

    if i mod 20 then

    sum=sum+a(i)

    end if

    next i

    print sum

    7a25ef219152fccb0f91db73aee4f50b.png

    扩展资料:

    在C++中,一维数组的引用格式为:数组名[下标]

    例如: int a[10];

    其中,a是一维数组的数组名,该数组有10个元素,依次表示为a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]。需要注意的是,a[10]不属于这一个数组的空间范围中。当在说明部分定义了一个数组变量后,编译程序会在内存空间中开辟一串连续的存储单元。

    对于数组而言,程序的执行部分使用的是数组变量而不是数组类型。需要注意的是:在引用时,下标可以是整型变量或整型表达式。如果使用表达式,会先计算表达式以确定下标。程序只能逐个应用数组中的元素而不能一次引用整个数组。

    展开全文
  • C语音 指针 指向一维数组元素

    千次阅读 2016-01-11 13:06:31
    前面我们已经学习了指针,如果指针存储了某个变量的地址,我们就...一、用指针指向一维数组元素 1 // 定义一个int类型的数组 2 int a[2]; 3 4 // 定义一个int类型的指针 5 int *p; 6 7 // 让指针指向

    前面我们已经学习了指针,如果指针存储了某个变量的地址,我们就可以说指针指向这个变量。数组及其数组元素都占有存储空间,都有自己的地址,因此指针变量可以指向整个数组,也可以指向数组元素。

    一、用指针指向一维数组的元素

    复制代码
     1 // 定义一个int类型的数组
     2 int a[2];
     3 
     4 // 定义一个int类型的指针
     5 int *p;
     6 
     7 // 让指针指向数组的第0个元素
     8 p = &a[0];
     9 
    10 // 修改所指向元素的值
    11 *p = 10;
    12 
    13 // 打印第一个元素的值
    14 printf("a[0] = %d", a[0]);
    复制代码

    输出结果:,说明已经通过指针间接修改了数组元素的值,跟指向一个普通int类型变量是一样的。

    由于数组名代表着数组的首地址,即a == &a[0],因此第8行代码等价于:

    // 让指针指向数组的第0个元素
    p = a;

    内存分析图如下,一个指针变量占用2个字节,一个int类型的数组元素占用2个字节


    二、用指针遍历数组元素

    1.最普通的遍历方式是用数组下标来遍历元素

    复制代码
    1 // 定义一个int类型的数组
    2 int a[4] = {1, 2, 3, 4};
    3 
    4 int i;
    5 for (i = 0; i < 4; i++) {
    6     printf("a[%d] = %d \n", i, a[i]);
    7 }
    复制代码

    输出结果:

     

    2.接下来我们用指针来遍历数组元素

    先定义一个指针,指向数组的第一个元素

    // 定义一个int类型的数组
    int a[4] = {1, 2, 3, 4};
    
    // 定义一个int类型的指针,并指向数组的第0个元素
    int *p = a;

    p的值是a[0]的地址,因此,现在我们利用指针p只能访问数组的第0个元素a[0],用*p就可取出a[0]的值1。要想访问其他元素,就必须拿到元素的地址,可以发现每个元素的地址差值为2,因为在16位编译器环境下,一个int类型的变量占用2个字节。现在只是知道a[0]的地址值为p,怎么根据a[0]的地址获取其他元素的地址呢?其实非常简单,p+1就是a[1]的地址。注意了,这里的p+1代表着p的值加2,并不是p的值加1,比如p的值为ffc3,p+1则为ffc5,而非ffc4。依次类推,p+2就是a[2]的地址ffc7,p+3就是a[3]的地址ffc9。

    我先解释一下,为什么p+1代表p的值加2,而不是加1呢?

    其实,p+1不一定代表p的值加2,也可能是加1、加4或者加8。究竟加多少,这跟指针的类型有关。下图是在16位编译器环境下的情况。

    聪明的你可能已经找到规律了,因为char类型的变量要占用1字节,所以p+1代表p的值加1;float类型的变量占用4字节,所以p+1代表p的值加4。从这一点,也可以很好地说明为什么指针一定要分类型,不同类型的指针,p+1的含义是不一样的。

    上述代码中的p指向了int类型的数组元素a[0],所以p+1代表p的值加2。知道怎么获取其他元素的地址了,那么就可以利用指针p遍历数组元素了。

    复制代码
     1 // 定义一个int类型的数组
     2 int a[4] = {1, 2, 3, 4};
     3 
     4 // 定义一个int类型的指针,并指向数组的第0个元素
     5 int *p = a;
     6 
     7 int i;
     8 for (i = 0; i < 4; i++) {
     9     // 利用指针运算符*取出数组元素的值
    10     int value = *(p+i);
    11     
    12     printf("a[%d] = %d \n", i, value);
    13 }
    复制代码

    注意第10行的代码,*(p+i)代表根据p+i的值(其实就是第i个数组元素的地址)访问对应的存储空间,并取出存储的内容(也就是取出第i个数组元素的值),赋值给左边的value。

    最后的输出效果是一样的:。注意的是:遍历完毕后,指针变量p还是指向a[0],因为p值一直没有变过,一直都是a[0]的地址ffc3

    补充一下,其实第10行改成下面的代码也是可以的:

    int value = *(a+i);

    大家都知道,a值代表数组的首地址,也就是a[0]的地址ffc3。a+1则代表a的值加2,即a[1]的地址ffc5,也就是说,a+i代表着元素a[i]的地址。相信大家也能猜出来了,a+1不一定代表着a值加2,究竟加多少,取决于数组的类型a+i的计算方法与p+i相同

     

    利用上面的方法遍历完数组元素后,p一直指向元素a[0]。其实我们也可以直接修改p的值来访问数组元素,只需要改一下第10行的代码即可

    // 利用指针运算符*取出数组元素的值
    int value = *(p++);

    p++其实就是相当于p = p + 1,直接修改了p值,而且每次是加2。因此,每执行一次p++,指针p就会指向下一个数组元素。

    输出结果肯定是一样的:。但是,遍历完毕后,指针变量p没有指向任何数组元素,因为一共执行了4次p++,最后p值为ffcb。当然,可以重新让p指向a[0]:p = &a[0];或者p = a;

    注意,这里的写法是错误

    int value = *(a++);

    a++相当于a=a+1,数组名a是个常量!不能进行赋值运算!

     

    三、指针与数组的总结

    p是指针,a是一个数组

    1> 如果p指向了一个数组元素,则p+1表示指向数组该元素的下一个元素。比如,假设p = &a[0],则p+1表示a[1]的地址

    2> 对于不同类型的数组元素,p值的改变是不同的。如果数组元素为int类型,p+1代表着p的值加上2(16位编译器环境下)

    3> 如果p的初值是&a[0],那么

    • p+i和a+i都可以表示元素a[i]的地址,它们都指向数组的第i个元素。a代表数组首地址,a+i也是地址,它的计算方法与p+i相同
    • *(p+i)和*(a+i)都表示数组元素a[i]
    • 虽然p+i和a+i都指向数组的第i个元素,但二者使用时还是有区别的。因为作为指针变量的p可以改变自身值,如p++,使p的值自增。而数组名a是一个代表数组首地址的常量,它的值是不能改变的,即a++是不合法的

    4> 引用一个数组元素可以有两种方法:

    • 下标法: 如a[i]
    • 指针法: 如*(p+i) 或 *(a+i)

     

    四、数组、指针与函数参数

    1.用数组名作为函数实参时,是把实参数组的首地址传递给形参数组,两个数组共同占用同一段内存空间,这样形参数组中的元素值发生变化就会使实参数组的元素值也同时变化

    复制代码
     1 void change(int b[]) {
     2     b[0] = 10;
     3 }
     4 
     5 int main()
     6 {
     7     // 定义一个int类型的数组
     8     int a[4] = {1, 2, 3, 4};
     9 
    10     // 将数组名a传入change函数中
    11     change(a);
    12     
    13     // 查看a[0]
    14     printf("a[0]=%d", a[0]);
    15     
    16     return 0;
    17 }
    复制代码

    change函数的形参是数组类型的,在第11行调用change函数时,将数组名a,也就是数组的地址传给了数组b。因此数组a和b占用着同一块内存空间。

    输出结果:

     

    2.这种地址的传递也可以用指针来实现。函数的实参和形参都可以分别使用数组或指针。这样就有4种情况:

    也就是说,如果一个函数的形参类型是一个数组,调用函数时,你可以传入数组名或者指针变量;

    复制代码
     1 void change(int b[]) {
     2     b[0] = 10;
     3 }
     4 
     5 int main()
     6 {
     7     // 定义一个int类型的数组
     8     int a[4] = {1, 2, 3, 4};
     9     
    10     int *p = a;
    11 
    12     // 将数组名a传入change函数中
    13     change(p);
    14     
    15     // 查看a[0]
    16     printf("a[0]=%d", a[0]);
    17     
    18     return 0;
    19 }
    复制代码

    注意第1行的形参类型是个数组int b[],第10行定义了指针变量p,第13行将p当做实参传入函数

     

    如果一个函数的形参类型是一个指针变量,调用函数时,你可以传入数组名或者指针变量。

    复制代码
     1 void change(int *b) {
     2     b[0] = 10;
     3     // 或者*b = 10;
     4 }
     5 
     6 int main()
     7 {
     8     // 定义一个int类型的数组
     9     int a[4] = {1, 2, 3, 4};
    10 
    11     // 将数组名a传入change函数中
    12     change(a);
    13     
    14     // 查看a[0]
    15     printf("a[0]=%d", a[0]);
    16     
    17     return 0;
    18 }
    复制代码

    注意第1行的形参类型是个指针变量int *b,第12行将数组名a当做实参传入函数。

    由第2行可以看出,在很多情况下,指针和数组是可以相互切换使用的。但是,并不能说指针就等于数组。

    展开全文
  • 已知一维数组 L[n]中存放实数序列 l1, l2…, ln,设计一个递归算法,求其中的最 大值及其所在数组元素下标: 程序思路:题目要求为利用递归函数找到一维数组的最大值及其下表。递归函数就是不 断地调用自身,所以...
  • 一维数组实质上是一组相同类型数据的线性集合,是数组中最简单的一种数组。本文将重点介绍一维数组的创建、初始化和使用。 创建一维数组 为了在程序中使用一个数组,必须声明一个引用该数组的变量,并指明整个变量...
  • 一、用指针指向一维数组元素二、用指针遍历数组元素三、指针与数组的总结四、数组、指针与函数参数 说明:这个C语言专题,是学习iOS开发的前奏。也为了让有面向对象语言开发经验的程序员,能够快速上手C语言。...
  • 一、用指针指向一维数组元素二、用指针遍历数组元素三、指针与数组的总结四、数组、指针与函数参数 前面我们已经学习了指针,如果指针存储了某个变量的地址,我们就可以说指针指向这个变量。数组及其数组...
  • 2012.3请编写函数fun,该函数的功能是:将M行N列的二维数组中的数据,按列的顺序依次放到一维数组中。一维数 组中数据的个数存放在形参n所指的存储单元中。例如,若二维数组中的数据为33 33 33 3344 44 44 4455 55 55 ...
  • C语言一维数组教案.doc学学 科科计算机科学与技术 课课 程程C 语言程序设计 课课 题题一维数组 课课 时时2 教学目标教学目标1、掌握一维数组的定义和引用 2、掌握一维数组的初始化方法 3、了解与一维数组有关的应用...
  • C++ 一维数组

    千次阅读 2019-12-16 20:36:05
    先来说一下一维数组的定义:一维数组即为下标只有一个的数组,一维数组也是最简单的数组 数组也就是一组按照顺序排列在一起且类型相同的多个数据,严格来说,数组并不是一种数据类型,而是一组相同数据类型的变量...
  • 一维数组 一位数组是最简单的数组类型,它的定义形式如下: 类型说明符 数组名[常量表达式] 类型说明符是数组中每个元素的类型,常量表达式是数组元素的个数 在使用一维数组的时候需要留意以下两个要点 常量表达式...
  • 算法题之-二维数组元素查找描述:给定的个二维数组,该二维数组从左往右从上往下依次增大,给定元素值,求该元素值是否是在该数组中 解决办法先将待查找元素key与数组最右上角元素设为a对比: 若a>key,因数值...
  • C语言指针重点难点整理(详解)(包括一维数组,二维数组的元素指针,二维数组的行指针做函数参数,指针数组,行指针数组) 笔者学指针之前: 呵呵,听闻指针是C语言的难点,我倒要见识一下,到底有多难 笔者学完...
  • C语言一维数组

    2019-11-23 20:43:54
    C语言一维数组1.1一维数组的定义和应用1.一维数组的定义2.一维数组的应用1.2一维数组的初始化 1.1一维数组的定义和应用 1.一维数组的定义 一维数组用以储存一位数列中数据的集合。其一般形式如下: 类型说明符 数组...
  • 个二维数组要想得到这种效果,需要添加行下标和列下标 题目为:定义个20*5的二维数组,用来存储某班级20位学员的5门课的成绩;这5门课 按存储顺序依次为:core C++,coreJava,Servlet,JSP和EJB。 由此可知,...
  • c语言引用数组元素时其数组下标的允许的数据类型是什么发布时间:2020-07-30 11:56:52来源:亿速云阅读:621作者:Leahc语言引用数组元素时其数组下标的允许的数据类型是什么?很多新手对此不是很清楚,为了帮助大家...
  • 一维数组中重复元素的去除

    千次阅读 多人点赞 2021-04-11 21:48:04
    一维数组中重复元素的去除前言一、基本思路二、步骤1.设置判断数组Arr[ ]:2.继承数组newArr[ ]获取不重复元素总结 前言 关于一维数组中有重复的元素该怎么剔除,作为java初学者的我整理出不调用任何特殊库的基础...
  • 我们遍历一维数组,正常的方法是改变数组的下标依次打印遍历数组。 代码如下: int a[10]={1,2,3,5,6,7,8,5,11,2},i=0; while(i<10){ printf("%d ",a[i++]); } putchar(10); 当然我们也可以用其他的循环方式...
  • java语言中的数组是一种引用数据类型,不属于基本数据类型,数组的父类是object类型。 数组实际上是一个容器,可以同时容纳多个元素。...数组的分类:一维数组,二维数组,三维数组,多维数组 所有的数组都有leng.
  • JavaScript数组数组数组的含义如何定义数组如何访问数组元素一维数组二维数组 数组 数组的含义 数组:是类型相同的数据的集合。 如何定义数组 方式一: 数组名 = new Array([数组的长度]) 例如: var arr = new ...
  • 元素分别为:x0 = [1, 2, 3]x1 = [4, 5, 6]x2 = [7, 8, 9]请将这3个一维数组元素交叉拼接后,组成一个新的一维数组y:y = [1, 4, 7, 2, 5, 8, 3, 6, 9]即新的数组y是从3个原始的一维数组依次分别取一个元素进行...
  • 一维数组

    千次阅读 2020-12-24 07:41:04
    一维数组

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,012
精华内容 10,404
关键字:

一维数组元素的下标依次是