精华内容
下载资源
问答
  • Python numpy实现二维数组和一维数组拼接的方法撰写时间:2017.5.23一维数组1.numpy初始化一维数组a = np.array([1,2,3]);print a.shape输出的值应该为(3,)二维数组2.numpy初始化二维数组a = np.array([[1,2,3]])...

    Python numpy实现二维数组和一维数组拼接的方法

    撰写时间:2017.5.23

    一维数组

    1.numpy初始化一维数组

    a = np.array([1,2,3]);

    print a.shape

    输出的值应该为(3,)

    二维数组

    2.numpy初始化二维数组

    a = np.array([[1,2,3]]);

    b = np.array([[1],[2],[3]]);

    print a.shape//(1,3)

    print b.shape//(3,1)

    注意(3,)和(3,1)的数组是不一样的,前者是一维数组,后者是二维数组。

    拼接

    3.numpy有很多的拼接函数。比如hstack和vstack等。网上又很多这样的总结帖子。但是两个数组能拼接的条件就是得满足两个数组的维度要相同。所以二维数组和一维数组拼接的时候需要使用newaxis将一维数组转化为二维数组,也就是shape从(3,)转化为(3,1)。

    a = np.array([1,2,3]);

    b = np.array([[1],[2],[3]]);

    #将一维数组a转化为二维数组

    a = a[:,np.newaxis];

    c = np.concatenate((b,a),axis=1)

    print c.shape//输出为(3,2)

    以上这篇Python numpy实现二维数组和一维数组拼接的方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

    时间: 2018-06-02

    最近找遍了python的各个函数发现无法直接生成随机的二维数组,其中包括random()相关的各种方法,都没有得到想要的结果.最后在一篇博客中受到启发,通过列表解析的方法得到随机的二维数组. 具体如下: a = [[random.randint(1, 4) for j in range(1, 3)] for i in range(1, 11)] print(array(a)) 其中random.randint(1, 4)用来产生一个随机整数.此时创建了一个10行2列的数组. [[1 3] [1

    关于python中的二维数组,主要有list和numpy.array两种. 好吧,其实还有matrices,但它必须是2维的,而numpy arrays (ndarrays) 可以是多维的. 我们主要讨论list和numpy.array的区别: 我们可以通过以下的代码看出二者的区别 >>import numpy as np >>a=[[1,2,3],[4,5,6],[7,8,9]] >>a [[1,2,3],[4,5,6],[7,8,9]] >>type(a

    题目的意思大致是在一个n*m的二维数组中,找到一个局部峰值.峰值要求大于相邻的四个元素(数组边界以外视为负无穷),比如最后我们找到峰值A[j][i],则有A[j][i] > A[j+1][i] && A[j][i] > A[j-1][i] && A[j][i] > A[j][i+1] && A[j][i] > A[j][i-1].返回该峰值的坐标和值. 当然,最简单直接的方法就是遍历所有数组元素,判断是否为峰值,时间复杂度为O(n^2

    本文实例讲述了Python实现二维数组按照某行或列排序的方法.分享给大家供大家参考,具体如下: lexsort支持对数组按指定行或列的顺序排序:是间接排序,lexsort不修改原数组,返回索引. (对应lexsort 一维数组的是argsort a.argsort()这么使用就可以:argsort也不修改原数组, 返回索引) 默认按最后一行元素有小到大排序, 返回最后一行元素排序后索引所在位置. 设数组a, 返回的索引ind,ind返回的是一维数组 对于一维数组, a[ind]就是排序后的数组.

    blank.gif

    本文实例讲述了Python简单获取二维数组行列数的方法.分享给大家供大家参考,具体如下: import numpy as np x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]]) # 输出数组的行和列数 print x.shape # (4, 3) # 只输出行数 print x.shape[0] # 4 # 只输出列数 print x.shape[1] # 3 本机测试运行结果如下图所示: 或者: >>> arr = [[1,4,7,10,1

    blank.gif

    二维数组 二维数组本质上是以数组作为数组元素的数组,即"数组的数组",类型说明符 数组名[常量表达式][常量表达式].二维数组又称为矩阵,行列数相等的矩阵称为方阵.对称矩阵a[i][j] = a[j][i],对角矩阵:n阶方阵主对角线外都是零元素. Python中创建二维数组 Python中的列表list可以当做一维数组使用,但是没有直接的定义使用二维数组.如果直接使用a = [][]会产生SyntaxError: invalid syntax语法不正确错误. 一般Python中创建二

    前不久对于Python输入二维数组有些不解,今日成功尝试,记以备忘.这里以输入1-9,3*3矩阵为例 n=int(input()) line=[[0]*n]*n for i in range(n): line[i]=input().split(' ') print(line) 使用数据转换为int即可! 以上这篇Python输入二维数组方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们. 您可能感兴趣的文章: 一些Python中的二维数组的操作方法 python中字

    有一道算法题题目的意思是在二维数组里找到一个峰值.要求复杂度为n. 解题思路是找田字(四边和中间横竖两行)中最大值,用分治法递归下一个象限的田字. 在用python定义一个二维数组时可以有list和numpy.array两种方式,看了几篇python中二维数组的建立的博客发现大多都是建立的初始化的二维数组,而我需要通过文件读取得到的是字符串,再把字符串转换为二维数组,找不到解决方法还是决定自己来转换. 首先,最开始的字符串输出如下,数字之间有空格 思路就是把先按换行符进行切片,再对每一行的字符再

    0.目录 1.遇到的问题 2.创建二维数组的办法 •3.1 直接创建法 •3.2 列表生成式法 •3.3 使用模块numpy创建 1.遇到的问题 今天写Python代码的时候遇到了一个大坑,差点就耽误我交作业了... 问题是这样的,我需要创建一个二维数组,如下: m = n = 3 test = [[0] * m] * n print("test =", test) 输出结果如下: test = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] 是不是看起来没有一点问

    使用new 创建二维数组方法 #include using namespace std; void main() { //用new创建一个二维数组,有两种方法,是等价的 //一: int (*p)[10] = new int[5][10]; //二: int **p = new int* [5]; for(int i=0;i <5;i++) p[i] = new int[10]; //指针数组的创建,也有两种方法 //一: char **pa = new char*

    对于二维数组,img_mask [[ 0 0 0 ..., 7 7 7] [ 0 0 0 ..., 7 7 7] [ 0 0 0 ..., 7 7 7] ..., [266 266 266 ..., 253 253 253] [266 266 266 ..., 253 253 253] [266 266 266 ..., 253 253 253]] 显示为图片的代码为: import matplotlib.pyplot as pyplot pyplot.imshow(im_mask) 以上这篇P

    L3Byb3h5L2h0dHAvZmlsZXMuamI1MS5uZXQvZmlsZV9pbWFnZXMvYXJ0aWNsZS8yMDE5MDkvMjAxOTkxODExMTAwMzQ5OS5qcGcmIzA2MzsyMDE5ODE4MTExMDE1.jpg

    本文实例为大家分享了C++利用函数动态创建二维数组的具体代码,供大家参考,具体内容如下 很简单,使用两个new创建即可. 运行截图及代码如下: #include #include #include #include using namespace std; int **creat(int m,int n) { int **p; int i,j; p = new int *[m]; f

    简介:由于经常在使用矩阵进行计算时,会首先将一维数组转为二维数组.因此,在这里记录一下,也希望对他人有帮助. 实例代码: package deal; public class ArryTest { public static void main(String[] args) { //创建一个一维数组 0,1,2,3...,10 double [] c= new double[10]; for (int i = 0; i < c.length; i++) { c[i]=i; } double[][

    展开全文
  • 后面的整个内容将围绕着一维数组展开,并且在学习一维数组之后会介绍一些一维数组的操作和使用。 表达式使用 我们在遇到的表达式里面通常包括: 关系表达式: 赋值表达式:= ,+= , -=, ×=, /=...

    一维数组

    C语言数据类型
    C语言数据类型,基本类型我们已经说明完了,下面我们开始说明构造类型。
    这篇博客提出我们在C语言中遇到的第一种构造类型就是数组。

    为什么说数组是一种构造类型呢,因为构造类型是由基本数据类型构造而成,构造类型是相对于基本类型来说的。

    构造类型和基本类型的关系:
    基本类型相当于是砖,构造类型相当于是一堵墙,当我们需要一堵墙的时候,我们可以一块砖一块砖的垒起来,也可以直接提供构造好的成品一堵墙。直接提供一堵墙就是构造类型。

    第一种构造类型:数组。
    数组到底解决了什么问题呢?
    我们下面举例说明:

    当我们用一堆变量来描述一类相同的数据时,比如有一百个年龄变量,我们可能定义成 int age1; int age2; int age3; int age4 ;int age5;…; int age100; 这样写语法上当然没有什么问题,但是这样写会带来一个问题就是既不方便于书写也不方便于管理。于是数组就出来了,我们可以使用 int age[100]搞定,里面包含100个变量,每个变量都是int类型的。通过age[ 0 ] 到 age[ 99 ] 来访问这100个变量。这样就和前面使用基本类型定义的方法达到了一样的效果,并且便于书写和管理。所以数组就是解决这类问题。

    构造类型,带来了书写和管理方便的同时,定义,大小,初始化和访问就不像基本类型那么简洁了。

    那么关于一维数组我们从哪些方面来研究呢?
    我们开始接触构造类型时研究它的定义,大小,初始化,访问

    对于任何的构造类型的研究都是从定义,大小,初始化和访问开始。
    这篇一维数组博客,我们也从以上四个方面开始研究。

    定义

    数组的定义:

    类型 数组名[数组长度];
    定义一维数组时,数组长度必须是整型常量。

    例如 :

    int array[20];
    

    上面代码表示定义一维数组:
    定义了一个数组名为array,包含20个元素,每个元素均为int类型的一维数组。

    例如:

      int  a = 10;
      int array[a];
    

    上面写法是不允许的,在vs2019中测试会出现错误
    其他平台可能编译会通过,但是初始化的时候一定会失败

    因为我们在强调过:
    定义一维数组的时候数组的长度必须是常量。

    一维数组的所有元素类型全部相同

    当然我们还有包含类型不同的构造类型,就是结构体,在之后博客我们将详细说明。

    大小

    这里,我们给出计算整个数组大小的方法和其中一个数组元素大小的方法,并且把计算数组元素个数的方法一起说明。

    定义一个一维数组:

    int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
    

    上面代码定义了一个数组名为array,包含10个元素,每个元素均为int类型的一维数组,并且进行了满初始化为1,2,3,4,5,6,7,8,9,10。

    下面我们通过代码演示一维数组的大小:

    #include <stdio.h>
    int main()
    {
    	int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
    	int length = sizeof(array) / sizeof(array[0]);
    	int length1 = sizeof(array) / sizeof(int);
    	//求数组中第一个元素的大小
    	printf("sizeof(array[0]) = %d\n", sizeof(array[0]));
    	//求整个数组的大小
    	printf("sizeof(array) = %d\n", sizeof(array));
    	//求数组有多少个元素
    	printf("array数组长度为%d\n", length);
    	//求数组有多少个元素
    	printf("array数组长度为%d\n", length1);
    	//求数组占多少个字节
    	printf("sizeof(array) = %d\n", sizeof(array));
    	//求int[10]占多少个字节
    	printf(" sizeof(int[10]) = %d\n", sizeof(int[10]));
    	return 0;
    }
    

    运行结果为:
    一维数组大小

    sizeof(array);
    

    sizeof(array);中array代表整个数组
    上面数组array是int类型,有10个元素,所以打印出来为40。

    初始化

    那么数组的定义和大小研究完了,我们就需要给数组进行初始化。

    满初始化

    在定义的时候直接初始化:

    int array[10] = {1,2,3,4,5,6,7,8,9,10};
    

    上面是一维数组满初始化的方法。

    在这里我们还有需要强调的点:
    数组不允许先定义,然后再以初始化的方式赋值。
    代码演示:

    int  array[10];
    array[10] = {1,2,3,4,5,6,7,8,9,10};
    

    重中之重:
    上面代码的初始化是绝对不允许的!!!
    说明:
    第一行代码:int array[10];表示:
    定义一个数组名为array,包含10个元素,每个元素均为int类型的一维数组。

    第二行代码:array[10] = {1,2,3,4,5,6,7,8,9,10};表示:
    赋值号 = 左边:array[10] 表示的是一维数组的越界元素,
    赋值号 = 右边:{1,2,3,4,5,6,7,8,9,10}表示数组,赋值号两边不匹配,所以是绝对不允许的

    对于所有构造类型,要么在定义的时候初始化, 要么对集合中的每个元素单独初始化。
    不允许先定义,然后再以初始化的方式赋值。

    那如果我们一定要先定义再赋值呢,那就必须通过循环来实现:

    #include <stdio.h>
    int main()
    {
    	int array[10];
    	for(int i = 0;i < 10;i++)
    	{
    		array[i] = i;
    	}
    	return 0;
    }
    

    上面就是先定义数组,然后通过循环方式赋值

    部分初始化

    那么如果我们给出 int array[10]; 但是我们不想一次把十个元素都初始化
    例如:

    int array[10] = {1,2,3,4,5};
    

    代码演示:打印部分初始化的一维数组

    #include <stdio.h>
    int main()
    {
    	int array[10] = { 1,2,3,4,5};
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%d\t", array[i]);
    	}
    	return 0;
    }
    

    运行结果为:
    打印一维数组部分初始化的运行结果
    我们可以看出来,一维数组前5个元素实现初始化,后面剩余未初始化的元素自动初始化为0。

    部分初始化的特殊情况:初始化清零

    #include <stdio.h>
    int main()
    {
    	int array[10] = {0};
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%d\n", array[i]);
    	}
    	return 0;
    }
    

    打印结果为:

    一维数组部分初始化的特殊情况

    上面运行结果是一维数组部分初始化的特殊情况。
    理解为:把第一个元素初始化为0,后面剩余的未初始化元素自动初始化为0。

    未初始化

    #include <stdio.h>
    int main()
    {
    	int array[10];
    	for(int i = 0;i<10;i++)
    	{
    		printf("%d\n",array[i]);
    	}
    	return 0;
    }
    

    打印结果为:
    一维数组未初始化

    如果一维数组只有定义,没有初始化。那么整个数组所有元素的值都为随机值且编译器会提醒数组未初始化

    不指定大小的初始化

    我们可以在初始化的时候不指定数组元素的个数,编译器将会自动得到数组的元素个数。
    例如:

    int array[] = {1,2,3,4,5,6,7};
    

    编译器将自动求得数组的元素个数

    问题:当数组元素少的时候我们自己可以数的清楚,当数组元素太多的时候我们怎么知道元素有多少个呢?

    我们给出以下方法:

    #include <stdio.h>
    
    int main()
    {
    	int array[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int length = sizeof(array) / sizeof(array[0]);
    	int length1 = sizeof(array) / sizeof(int);
    	printf("数组长度为%d\n", length);          //求数组有多少个元素
    	printf("数组长度为%d\n", length1);         //求数组有多少个元素
    	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
    	{
    		printf("%d\t",array[i]);
    	}
    	return 0;
    }
    

    运行结果为:
    在这里插入图片描述

    以上,我们通过整个数组的大小去除以数组中一个元素的大小来求出数组的元素个数,以上我们给出两种,分别是length和length1两种方法都可以求出,但是我们认为第一种更好,用整个数组的大小除以其中一个元素的大小来获得元素个数,第二种通过除以数组元素类型的大小也完全正确,但是第一种更加容易理解。

    不指定大小的数组是我们经常会使用到的。

    初始化总结

    初始化总结

    访问

    数组在访问的时候我们通过下标来访问:

    #include <stdio.h>
    
    int main()
    {
    	int array[10] = {1,2,3,4,5,6,7,8,9,10};
    	printf("%d\n", array[6]);
    	printf("%d\n", array[3]);
    	printf("%d\n", array[9]);
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%d\t", array[i]);
    	}
    	return 0;
    }
    

    运行结果为:
    访问一维数组运行结果

    上面运行结果都是通过数组下标来访问数组元素,目前我们访问一维数组的元素数据都是通过数组下标的方式访问,只不过我们使用for循环可以更加方便的通过数组下标来访问一维数组的元素,本质相同。

    一维数组本质理解

    那么这里有一个需要重点理解的问题:

    a是int类型,那么arr是什么类型的呢?
    arr类型我们只能说是数组类型,它的类型是不确定的,由我们构造而成。

    #include <stdio.h>
    int main()
    {
        int arr[10] = {0};
        int a = 10;
        printf("sizeof(a) = %d\n",sizeof(a));
        printf("sizeof(int) = %d\n",sizeof(int));
    
        printf("sizeof(arr) = %d\n",sizeof(arr));
        printf("sizeof(int[10]) = %d\n",sizeof(int[10]));
        return 0;
    }
    

    运行结果为:
    一维数组的本质理解

    那么我们定义数组的时候:

    int  arr[10];
    

    就应该理解为:

    int[10]   arr;
    

    arr 是 int[10] 类型。
    前面是类型,后面是变量

    只是上面int[10] arr;写法在语法不允许通过,但是理解一维数组本质就是int[10] arr;的格式。

    我们在前面已经打印出来int[10] 类型的大小为40字节。

    一维数组是一种构造类型,构造类型每个成员的大小和长度都是不确定的。

    构造类型是一种很宽泛的概念,例如int [10] 类型可以改为 char[100] 类型等多种构造类型。

    构造类型,就是相当于产生一种新的类型。

    越界

    在一维数组这里,我们说到两种越界;
    在这里需要强调很重要的一点:C语言对越界不检查
    这里说明的越界分别是:越界访问和越界初始化。
    越界是非法的,不合理的,也是应该被禁止的。

    但是这种越界不检查并不是一个错误行为,后面我们就会发现这种不检查行为带来了极大的灵活性。就好比玩匕首一样,匕首上没有防护装置,比较灵活,但是一不小心容易割到自己。

    越界初始化

    #include <stdio.h>
    int main()
    {
        int arr[2] = {1,2,3,4};
        printf("sizeof(arr) = %d",sizeof(arr));
        return 0;
    }
    

    上面初始化数组,数组大小只能存储2个元素而在初始化给了4个元素出现越界初始化。
    在编译器中出现越界访问和越界初始化编译时会出现警告,不会出现错误。
    上面代码在VS2019编译器会出现错误:
    VS2019编译器出错

    但是在Qt平台只会出现警告,编译能够通过,运行结果为:
    Qt平台越界初始化运行结果

    越界访问

    #include <stdio.h>
    int main()
    {
    	int array[2] = {1,2};
    	for (int i = 0; i < 4; i++)
    	{
    		printf("%d\t", array[i]);
    	}
    	return 0;
    }
    

    在VS2019编译器运行结果为:
    越界访问在VS2019编译器运行结果

    在Qt编译器运行结果为:
    越界访问在Qt编译器运行结果

    上面数组定义和初始化的时候只有2个元素,但是访问的时候访问到了下标为2,3的空间,出现越界访问。

    越界访问和越界初始化都是应该被禁止的,但是C语言层面并没有给出强硬的措施。
    并没有让程序直接出现错误或者崩溃。

    在实际开发中,不要出现越界访问和越界初始化。

    一维数组的存储

    一维数组的逻辑是一维的,也可以说是线性的。并且一维数组在逻辑上和物理上都是连续的。

    一维数组,在内存中是一段连续的存储区域。
    格式如下:
    一维数组的物理存储

    上面一维数组的物理存储有40个空间,10个int类型元素,并且是一段连续的内存空间。
    一维数组在逻辑上是连续的,在物理存储中也是连续的。
    代码演示:

    #include <stdio.h>
    int main()
    {
    	int array[10];
    	for (int i = 0; i < 10; i++)
    	{
    		printf("&arr[%d] : %p\n", i, &array[i]);
    	}
    	return 0;
    }
    

    运行结果为:
    数组的连续存储空间

    我们可以看到一维数组低序号下标的元素存储在内存中的低地址,并且证明了一维数组是连续的物理存储区域。

    数组三要素

    三要素图示

    数组的声明中,己经把数组访问的三要素,均己表示出来了,三要素就是:
    起始位置,移步刻度(步长),终止位置(范围)。

    数组的三要素

    起始地址

    #include <stdio.h>
    
    int main()
    {
    
    	int array[5] = { 1,2,3,4 };
    	printf("array = %p, &array[0] = %p\n", array,&array[0]);
    	return 0;
    }
    

    运行结果为:
    一维数组的起始地址

    我们在这里说明第一点:
    我们上面并没有对于arr进行使用取地址符号,arr数组名就是代表数组的首元素起始地址,就是数组第一个元素的地址

    那么有了数组的首元素起始地址,描述这段内存空间就变的简单了。有起始地址,有了步长,每次+1就有了成员偏移的刻度,就是步长。但是不能无限制的跳跃下去,所以就有了范范围。

    步长

    
    #include <stdio.h>
    int main()
    {
    	int array[5] = { 1,2,3,4 };
    	printf("arr = %d\narr+1 = %d\narray + 2 = %d\n", array, array + 1, array + 2);
    	return 0;
    }
    

    运行结果为:
    一维数组的步长
    步长的大小是数组元素类型的大小,每一次偏移的单位的大小就是步长,上面定义一维数组类型为int类型,所以通过十进制打印出来的一维数组相邻元素偏移相差为4。

    范围

    #include <stdio.h>
    
    int main()
    {
    
        int array[5] = { 1,2,3,4 };
    	printf("sizeof(array)/array[0] = %d", sizeof(array) / sizeof(array[0]));
    		return 0;
    }
    

    运行结果为:
    一维数组的范围
    数组的元素个数就是数组的范围。
    范围保证数组元素的偏移不能无限制的偏移下去。
    每次写循环都要使用范围,来保证不越界。

    数组的下标为什么从零开始?

    所有学习过 C 语言的人,可能都会有一个疑问:
    数组的下标为什么从0开始,不从1开始呢?
    因为 C语言,脱胎于汇编语言,稍微懂点汇编的读者,就知道 [ ] 是一种基址变址运算符
    基于起始位置偏移 0 个单位取到的就是数组的第一个元素,元素大小以数组类型所占字节大小为单位存取数据,故下标从 0 处开始。

    代码演示:

    #include <stdio.h>
    
    int main()
    {
    	int array[10];
    	for (int i = 0; i < 10; i++)
    		printf("%d : %p\n",i,&array[i]);
    	for (int i = 0; i < 10; i++)
    		printf("%d : %p\n", i, (array+i));
    	return 0;
    }
    

    运行结果为:
    数组的下标取地址和偏移量取地址

    #include <stdio.h>
    
    int main()
    {
    	int array[10] = {1,2,3,4,5,6,7,8,9,10};
    	for (int i = 0; i < 10; i++)
    		printf("%d : %d\n", i, array[i]);
    	printf("\n======\n\n");
    	for (int i = 0; i < 10; i++)
    		printf("%d : %d\n", i, *(array + i));
    	return 0;
    }
    

    运行结果为:
    数组的下标取数据和偏移量取数据
    通过上面运行结果,我们可以得到使用数组下标取地址和使用地址的偏移量取到的地址是一样的。

    一维数组的数组名除了代表构造类型,还表示一维数组的首元素起始地址,参与首元素的访问。

    ①:代表构造类型:int[10] array;
    ②:表示一维数组的首元素起始地址:
    代码演示:

    #include <stdio.h>
    int main()
    {
    	int array[10] = { 1,2,3,4,5 };
    	printf("%d %d %d\n", array[1], 1[array],*(array+1));
    	printf("%d %d %d\n", array[0], 0[array], *(array + 0));
    	printf("&arr[0] = %d\n", &array[0]);
    	printf("arr = %d\n", array);
    	return 0;
    }
    

    运行结果为:
    基址变址运算符说明

    通常[ ] 是下标运算符。我们对于 [ ] 更加深入的理解就是:
    [ ] 是基址变址运算符,array代表首元素地址
    我们已经通过上面代码打印说明。
    上面array[1] 的本质相当于从array这个地址偏移了一个单位。然后取这个单位的数据。
    这里单位就是步长。上面代码中单位是int ,步长为4字节。

    一维数组的简单应用

    求一维数组的最大值,最小值,平均值,求和
    在简单应用里面我们学习求一维数组的最大值,最小值,平均值,求和

    #include <stdio.h>
    int main()
    {
    	int array[10] = { 2,5,1,7,5,10,30,50,12,43 };
    	int sum = 0;    //定义数组之和
    	int max = array[1];//定义最大值先赋值为数组的第一个元素,然后和数组中其他进行比较
    	int min = array[1];//定义最小值先赋值为数组的第一个元素,后和数组中其他进行比较
    	float average = 0; //定义数组的平均数
    	int len = sizeof(array) / sizeof(array[0]);   //求数组长度
    	for (int i = 0; i < 10; i++)
    	{
    		sum += array[i];             //求和
    		if (array[i] > max)
    		{
    			max = array[i];          //得到最大值
    		}
    		if (array[i] < min)
    		{
    			min = array[i];          //得到最小值
    		}
    	}
    	average = (float)sum / len;
    	printf("sum = %d\n", sum);
    	printf("max = %d\n", max);
    	printf("min = %d\n", min);
    	printf("average = %.2f\n", average);
    	return 0;
    }
    

    打印结果为:

    一维数组简单运用

    数组名的二义性

    我们先来看一下在结构体中的数据成员访问方式:

    #include <stdio.h>
    
    struct    //结构体
    {
    	int a;
    	char b;
    }xx;
    
    int main()
    {
    	xx.a;//访问结构体成员方式 
    	xx.b;//访问结构体成员方式
    	return 0;
    }
    

    上面对于构造类型结构体的成员访问中,系统专门为其设置了成员运算符来访问结构体成员。

    因为对于结构体来说,里面的成员类型大小不一样,每一个类型的元素要单独处理,所以对于结构体类型,通过构造定义了类型,定义了变量,定义了结构体成员的访问方式。

    但是对于数组来说,里面的成员类型大小是一样的,所以可以通过偏移步长来对于每一个数组成员进行操作。所以数组名既表示数组是构造类型,也表示数组首元素的地址。

    数组名代表首元素地址,代码演示:

    #include <stdio.h>
    int main()
    {
    	int array[10] = { 0,1,2,3,4,5,6,7,8,9 };
    	printf("%x  %x", array, &array[0]);
    	return 0;
    }
    

    运行结果为:
    数组名代表首元素地址

    小结

    相同的数据类型进行构造,就组成了数组。
    不同的数据类型进行构造,就成了结构体。

    凡是构造类型,要么在定义的时候初始化, 要么对集合中的每个元素单独初始化。不允许先定义,然后再以初始化的方式赋值。

    凡是基础数据类型,既可以在定义的时候初始化,也可以先定义,再赋值。

    一维数组的逻辑是一维的,对于其成员的访问,即一维数组的读写,往往通过一重循环来实现。

    一维数组名的用法

    在一维数组中:
    下面两种情况一维数组名表示整个数组:

    sizeof(array)

    sizeof(array);中array代表整个数组

    #include <stdio.h>
    
    int main()
    {
    
    	int array[5] = { 1,2,3,4 };
    	printf("arr = %d,arr+1 = %d\n", array, array + 1);
    	return 0;
    }
    	
    

    运行结果为:
    运行结果

    如果直接使用数组名+1 则表示从数组首地址开始的下一个元素。及就是数组三要素中的步长。上面例子中一维数组的数组元素是int类型,大小为4字节。

    #include <stdio.h>
    int main()
    {
    	int arr[5] = { 1,2,3,4,5 };
    	printf("arr = %d arr+1 = %d\n", &arr, &arr + 1);
    	return 0;
    }
    

    运行结果为:
    运行结果

    我们可以看到&arr+1 会越过整个数组,因为 arr 是 int [ 5 ] 类型。

    区分初始化和赋值

    在定义的时候给变量值,就是初始化。
    例如:

    int a = 10;
    

    先定义,后给变量值就是赋值。
    例如:

    int a ;
    a = 10;
    

    变长数组

    前面说明的数组大小,要么是事先给定的,要么通过初始化元素的个数决定的。那么数组的大小,可不可以是变量呢,即大小是可以变化的呢?

    C99 为了增加 c 语言的灵活性,提供了变长数组的概念,(variable-length array)也简称 VLA。即数组的大小,可以是变量。

    变长数组是指用整型变量或表达式声明数组的长度来定义数组,而不是说数组的长度会随时变化,变长数组在其生存期内的长度同样是固定的。

    #include <stdio.h>
    int main(void)
    {
        int size = 20;
        scanf_s("%d", &size);
        int array[size]; //变长数组不能被初始化 = {1,2,3,4,5};
        printf("sizeof(array) = %d\n", sizeof(array));
        printf("array[0] = %d\n",array[0]);
        printf("array[1] = %d\n",array[1]);
        size = 15; //此时再改变 size 的值,数组的大小,不再发生改变
        printf("sizeof(array) = %d\n", sizeof(array));
        return 0;
    }
    
    

    在Qt编译器运行结果为:
    变长数组

    上面代码在VS2019平台会出现编译失败。
    编译错误

    注意:变长数组有平台差异性,以 linux 平台为准。

    所谓变长数组,就是运行开始,有一次改变大小的机会,在其后运行期间不可以改变数组大小。且变长数组不能被初始化。我们上面代码已经验证,下面我们再次通过代码强调。
    代码演示:

    #include <stdio.h>
    int main()
    {
        int var = 100;
        int arr[var];
        printf("sizeof(arr) = %d\n",sizeof(arr));
        var = 200;
        printf("sizeof(arr) = %d", sizeof(arr));
        return 0;
    }
    

    在Qt平台运行结果为:
    变长数组

    在VS2019编译器中编译不能通过。
    编译错误

    提示数组长度必须为常量。

    展开全文
  • Java 多维数组是由一维数组组合而成,这种说法是否正确?Java 多维数组是由一维数组组合而成,这种说法是否正确?明天Java考试了 有没有大神帮帮忙呢一、选择题1.对象的静态特征在类中表示为变量,称为类的(B)A....

    Java 多维数组是由一维数组组合而成,这种说法是否正确?

    Java 多维数组是由一维数组组合而成,这种说法是否正确?

    明天Java考试了 有没有大神帮帮忙呢

    一、选择题

    1.对象的静态特征在类中表示为变量,称为类的(B)

    A.对象 B.属性 C.方法 D.数据类型

    2.关于类的描叙正确的是()(选择两项)

    A.在类中定义的变量称为类的成员变量,在其他的类中可以直接使用。

    B.局部变量的作用范围仅仅在定义它的方法内,或者是在定义它的控制流块中。

    C.使用其他的类的方法仅仅需要引用方法的名字即可。

    D.一个类的方法使用该类的另一个方法时可以直接引用方法名。

    3.在Java中,关于构造方法,下列说法错误的是( )

    A.构造方法的名称必须与类名相同

    B.构造方法可以带参数

    C.构造方法不可以重载

    D.构造方法绝对不能有返回值

    4.给定java代码如下所示,在A处新增下列()方法,是对cal方法的重载(选择两项)

    public class Test {

    public void cal(int x, int y, int z)

    {}

    //A

    }

    A.public int cal(int x,int y,float z){return 0;}

    B.public int cal(int x,int y,int z){return 0;}

    C.public void cal(int x,int z){}

    D.public viod cal(int z,int y,int x){}

    5.在Java中,下面对于构造函数的描述错误的是()(选择两项)

    A.类不一定要显式定义构造函数

    B.构造函数的返回类型是void

    C.如果构造函数不带任何参数,那么构造函数的名称和类名可以不同

    D.一个类可以定义多个构造函数

    6.在JAVA中,Object类是所有类的父亲,用户自定义类默认扩展自Object类,下列选项

    中的()方法不属于Object类的方法。

    A.equals(Object obj)

    B. getClass()

    C.toString()

    D.trim()

    7.Java中,如果类C是类B的子类,类B是类A的子类,那么下面描述正确的是()

    A.C不仅继承了B中的成员,同样也继承了A中的成员

    B.C只继承了B中的成员

    C.C只继承了A中的成员

    D.C不能继承A或B中的成员

    8.分析选项中关于Java中this关键字的说法正确的是()

    A. this关键字是在对象内部指代自身的引用

    B.this关键字可以在类中的任何位置使用

    C.this关键字和类关联,而不是和特定的对象关联

    D.同一个类的不同对象共用一个this

    展开全文
  • C语言一维数组教案学 科:计算机科学与技术课 程:C语言程序设计课 题:一维数组课 时:2教学目标:1、掌握一维数组定义和引用2、掌握一维数组的初始化方法3、了解与一维数组有关的应用编程方法教学重点:一维数组...

    C语言一维数组教案

    学 科:计算机科学与技术

    课 程:C语言程序设计

    课 题:一维数组

    课 时:2

    教学目标:1、掌握一维数组的定义和引用

    2、掌握一维数组的初始化方法

    3、了解与一维数组有关的应用编程方法

    教学重点:一维数组的定义和引用、初始化方法

    教学难点:与一维数组有关的应用编程方法

    教学方法:举例法,引导法

    教学步骤: 1、通过一个例子提出问题来引出本节课的知识点

    2、讲授一维数组的定义和引用、初始化方法

    3、示例训练

    4、进行本节课的总结及作业布置

    教 具:黑板 计算机 投影仪

    教学过程:

    一、导入:

    提问:保存一个班50位同学的一门功课的成绩,并且找出最高分和最低分,应如何实现?

    解题思路:定义50个变量,从键盘中输入值,然后再相互比较。处理起来很复杂,是否有更简便的方法?引出本节课的知识点-----数组。

    二、讲授:

    1、数组概述:

    ·数组:是数目固定,类型相同的若干个变量的有序集合,用数组名标识。

    序:是数组元素之间的位置关系,不是元素值的大小顺序。

    数组名:是用于区别其它数组及变量的。

    ·数组元素:集合中的变量,属同一数据类型,用数组名和下标确定。

    下标:是数组元素在数组中的位置。

    ·数组的维数:数组名后所跟下标的个数。

    2、一维数组的定义

    一维数组是指由一个下标数组元素组成的数组。其定义形式为:

    存储类型 数据类型 数组名[常量表达式]

    例如:static int score[50];

    它表示定义了一个名为score的数组,该数组有50个元素,其存储类型为静态型,数据类型为整型。

    说明:

    (1)存储类型为任选项,可以是auto、static、extern存储类型,但是没有register型。

    (2)数据类型是用来说明数组元素的类型:int , char , float。

    (3)数组名的命名应遵守标识符的命名规则,但是不能与其他变量同名。

    (4)数组名后是用方括号[ ]括起来的常量表达式。常量表达式表示的是数组元素的个数,即数组的长度。在上例中定义了数组score [50],第一个元素为score [0],最后一个为score [49]。

    (5)常量表达式中可以包括常量和符号常量,不能包含变量,因为C语言规定不允许对数组的大小作动态定义。

    (6)允许在同一个类型说明中,说明多个数组和多个变量,彼此间以逗号相隔。

    例如:int a,b,k1[10],k2[20]; //定义了两个一维数组、两个整型变量

    判断下面的定义是否合法:

    int b, b[5]; //不合法,数组名不能与变量名同名

    #define size 10

    int b[size]; //合法,size已经在宏定义中说明,在程序中作为符号常量

    int a(6); //不合法,数组名后不能使用(),只能用[]

    int n=5;

    int a[n]; //不合法,不能用变量定义数组元素的个数

    int a[n+2]; //不合法,不能用变量表达式定义数组元素的个数

    一维数组的存储结构:C语言在编译时给数组分配一段连续的内存空间。内存字节数=数组元素个数*sizeof(元素数据类型)

    数组元素按下标递增的次序连续存放。数组名是数组所占内存区域的首地址,即数组第一个元素存放的地址。

    例 int a[5]; 假设首地址是2000

    a[0]a[1]a[2]a[3]a[4] 内存地址 2000 2002 2004 2006 2008

    占用字节数为:5*sizeof(int)=5*2=10

    3、一维数组元素的引用

    数组元素是组成数组的基本单元。数组元素用数组名和下标确定。下标表示了元素在数组中的顺序号,C语言规定:数组必须先定义,后使用。一维数组的引用形式为:

    数组名[下标]

    其中下标可以是整型常量、整型变量或整型表达式。例如有定义:

    int t,a[10],i=2;

    则以下都是正确的表达式:

    t=a [6];

    a[0]= a[i]+a[i+1];

    引用说明:

    (1)必须像使用变量那样,先定义,再使用,如以下操作是错误的:

    int x=a[2];

    int a[10];

    (2)下标的最小值为0,最大值是数组大小减1。在前例中定义了数组score [50],使用的时候不能使用 score [50], 否则产生数组越界。C语言对数组不作越界检查,使用时要注意!

    (3)在C语言中只能对数组元素进行操作,不能一次对整个数组进行操作。例如要输出有10个元素的数组,则必须使用循环语句逐个输出各下标变量:

    for(i=0; i<10; i++)

    展开全文
  • 定义一维数组

    千次阅读 2019-01-26 21:57:06
    1.一维数组定义格式为: 类型说明符 数组名[常量表达式]; 例如: int a[10]; 它表示定义了一个整形数组,数组名为a,有10个元素。 2.在定义数组时,需要指定数组中元素的个数,方括弧中的常量表达式用来表示...
  • 一维数组定义方式

    万次阅读 2016-08-11 20:14:26
    一维数组定义方式 在C语言中使用数组必须先进行定义一维数组定义方式为:  类型说明符 数组名 [常量表达式]; 其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号...
  • C语言一维数组定义及初始化

    千次阅读 2020-10-14 13:39:11
    定义一维数组2. 一维数组初始化 1. 定义一维数组 一般形式: 类型说明符 数组名[常量表达式] eg: int a[10]; 下标从0开始,这10个元素是从a[0]~a[9] 类型说明符:指定数组中元素的类型 ,a中所有元素都是int类型...
  • 正确定义维数组

    万次阅读 多人点赞 2019-06-24 16:23:17
    维数组进行正确初始化 二维数组必须指定列的数量,行的数量可以不定义即可以省略第一维定义,但不能省略第二维的定义 1.分行进行初始化 int a[2][3] = {{1,2,3},{4,5,6}}; 在{}内部再用{}把各行分分开,第0行...
  • C语言一维数组定义与常见用法

    千次阅读 2020-05-07 16:54:48
    一维数组定义与初始化 一维数组指的是只有一个下标的数组,它用来表示一组具有相同类型的数据。在C语言中,一维数组定义方式如下所示 类型说明符 数组名[常量表达式]; 在上述语法格式中,类型说明符表示...
  • 一维数组定义

    千次阅读 2019-04-10 16:42:04
    一维数组通用的声明方式:类型名[]数组名; 1)先声明后初始化方式: int[]arr; arr=newint[5];//数组中包含5个元素,每一个元素的初始值都是int类型的默认值0 2)声明的同时进行初始化方式 int[]arr=newint[]{1,2,3};...
  • JAVA中一维数组和二维数组的定义

    万次阅读 多人点赞 2008-12-30 15:28:00
    在java中数组被看成是一个对象在定义数组时,有两种定义方法:int[] a 和int a[];第二种是C/C++对数组定义方式,对于JAVA...1 一维数组定义 //定义包含三个元素的一维数组 //方法1,先new对象,然后再初始化每个元
  • (1) 如何定义(声明)一维数组? 声明格式:数据类型[] 数组名称; (2) 数组的初始化 数组声明之后就需要初始化,即:分配内存空间。使用关键字new为数组分配内存空间。 初始化格式:数据类型[] 数组名称 = new ...
  • 一、一维数组定义 类型说明符 数组名[常量表达式] int a[10];//a为整型数组,有10个元素 二、为何引入数组 引入数组是为了便于处理大量的数据的问题可以创造多个变量 数组名构成与一般变量名相同,常量表达...
  • 数组的定义 定义:是长度固定的,存储元素类型相同的容器. 数组的分类 按维度分: 一维数组 二维数组 多维数组 按类型分 ...一维数组: 定义:一维数组是使用一个下标访问数组元素的数组 ...
  • C++ 一维数组

    千次阅读 2019-12-16 20:36:05
    先来说一下一维数组定义一维数组即为下标只有一个的数组,一维数组也是最简单的数组 数组也就是一组按照顺序排列在一起且类型相同的多个数据,严格来说,数组并不是一种数据类型,而是一组相同数据类型的变量...
  • 1.一维数组定义 类型名 数组名[元素个数]; double array[10]; 类型名:每个数组元素的数据类型 数组名:储存该数组的变量名 数组的元素个数必须是编译时的常量 #define len1 10; const int len2 = 5; double ...
  • 《C语言-一维数组定义和引用-数组.ppt》由会员分享,可在线阅读,更多相关《C语言-一维数组定义和引用-数组.ppt(47页珍藏版)》请在人人文库网上搜索。1、第七章分组数组:它是一种构造类型,元素由基本类型(整体...
  • // // main.cpp // 二维数组 // 1.一个二维数组就像是若干个相同的数组放在一起,这对于存储多组...处理二维数组的时候直接当作一维数组就可以了每一行都是一个一维数组。 // 5.二维数组在存储的时候,是按照一行...
  • c语言一维数组练习题精品文档2016全新精品资料-全新公文范文-全程指导写作 –独家原创 PAGE1 / NUMPAGES1 c语言一维数组练习题 4.1内容概述本章主要介绍了数值数组和字符数组的定义、初始化、元素引用和数组数据的...
  • 5.1一维数组

    2020-06-22 16:29:49
    一、一维数组定义 二、一维数组的初始化 完全初始化 不完全初始化 不初始化 清零 初始化的几种错误写法 三、一维数组的引用 四、一维数组的特点 五、一维数组的操作 排序 冒泡排序 选择排序 添加&删除&...
  • c语言一维数组定义、初始化

    千次阅读 2015-09-02 23:32:36
    一维数组 1、定义:是一组具有相同数据类型的有序元素集合。 2、初始化: (1)、初始化方式一: //数组的定义: int a[length]; //这是数组的定义 //可以使用for循环进行遍历初始化 for (int i = 0; i ; ...
  • 小结了一维数组和二维数组的创建与初始化、使用、存储、指针访问和几个小点
  • java数组:一维数组

    2021-02-09 14:46:58
    3、对一维数组中的元素访问4、 一维数组的遍历5、静态存储Object类6、动态初始化一维数组7、什么时候采用静态初始化方法/动态初始化方法? 数组:Array 1、数组相关基础知识 1、Java语言中的数组是一种引用数据类型...
  • 一维数组:arr = input("") //输入一个一维数组,每个数之间使空格隔开num = [int(n) for n in arr.split()] //将输入每个数以空格键隔开做成数组print(num) //打印数组一维数组输入输出示例:​​​二维数组:(以n*...
  • 在做项目的时候遇到一个将一维数组转为二维数组的问题。...现在data中定义两个列表,一个用于接收接口拿来的一维数组列表,另一个用于存放转成二位之后的数组列表 data() { return { //这个是给接口
  • 定义一维、二维、三维数组

    万次阅读 2016-12-24 20:10:42
    声明一个简单一维数组形式如下: type name [size]; type:数组数据类型 name:数组名 size:数组元素个数 数组名是该数组首元素的地址 不能把整个数组作为参数传递给函数,但是可以传递数组的地
  • 维数组定义方法

    千次阅读 2020-07-08 14:22:19
    m表示这个二维数组有多少个一维数组 n表示每一个一维数组的元素个数 举例:int[][] arr = new int[3][2]; 定义了一个二维数组arr 这个二维数组有3个一维数组,名称是arr[0],arr[1],arr[2] 每个一维数组有2个...
  • c语言==一维数组与二维数组(2)

    千次阅读 2016-07-07 17:34:06
    一维数组与二维数组 排序,输出三角形
  • 一维数组

    2019-05-23 08:50:58
    数组定义 类型说明符 数组名[常量表达式]; int a[10] //正确 ... 它表示定义个整型数组数组名为 a定义数组称为数组 a数组a 除了表示该数组之外,还表示该数组的首地址。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,033
精华内容 26,013
关键字:

以下对一维数组a的正确定义是