精华内容
下载资源
问答
  • 背景我们知道大部分编程语言中的数组都是0开始编号的,即array[0]是数组的第一个元素。这个和我们平时生活中1开始编号的习惯相比显得很反人类。那么究竟是什么样的原因让大部分编程语言数组都遵从了这个神奇的...

    背景

    我们知道大部分编程语言中的数组都是从0开始编号的,即array[0]是数组的第一个元素。这个和我们平时生活中从1开始编号的习惯相比显得很反人类。那么究竟是什么样的原因让大部分编程语言数组都遵从了这个神奇的习惯呢?本文最初是受stackoverflow上的一个问题的启发,通过搜集和阅读了一些资料在这里做个总结。当然,本文摘录较多的过程结论,如果你想把这篇文章当做快餐享用的话,可以直接跳到文章末尾看结论。

    最早的原因

    在回答大部分我们无法解释的诡异问题时,我们最常用的辩词通常是历史原因。那么,历史又是出于什么原因,使用了0标号数组呢?Mike Hoye就是本着这么一种追根刨地的科学精神为我们找到了解答。以下是一些他的重要结论的摘录翻译:

    据作者的说法,C语言中从0开始标号的做法是沿用了BCPL这门编程语言的做法。而BCPL中如果一个变量是指针的话,那么该指针可以指向一系列连续的相同类型的数值。那么p+0就代表了这一串数值的第一个。在BCPL中数组第5个元素的写法是p!5,而C语言中把写法改成了p[5],也就是现在的数组。具体原文摘录如下:

    If a BCPL variable represents a pointer, it points to one or more consecutive words of memory. These words are the same size as BCPL variables. Just as machine code allows address arithmetic so does BCPL, so if p is a pointer p+1 is a pointer to the next word after the one p points to. Naturally p+0 has the same value as p. The monodic indirection operator ! takes a pointer as it’s argument and returns the contents of the word pointed to. If v is a pointer !(v+I) will access the word pointed to by v+I.

    至于为什么C语言中为什么使用[]方括号来表示数组下标,这个设计也有一定来历。据C语言作者的说法是方括号是现代键盘上唯一较为容易输入的成对符号(不用shift)不信你对着键盘找找?

    为什么这个反人类设计在一段时间内一直没有被改变

    根据Mike的说法,BCPL是被设计在IBM硬件环境下编译运行的。在1960后的很长一段时间内,服务器硬件几乎被IBM统治。一个城市内也许至于一台超级计算机,还需要根据时间配额使用。当你当天的配额用完以后,你的程序就被完全清出计算队列。甚至连计算结果都不给你保留,死无全尸。这个时候写一段高效的程序,就显得比什么都重要了。而这时0下标数组又体现了出了它的另一个优势,就是:相较于1下标数组,它的编译效率更高。原文摘录如下:

    So: the technical reason we started counting arrays at zero is that in the mid-1960’s, you could shave a few cycles off of a program’s compilation time on an IBM 7094. The social reason is that we had to save every cycle we could, because if the job didn’t finish fast it might not finish at all and you never know when you’re getting bumped off the hardware because the President of IBM just called and fuck your thesis, it’s yacht-racing time.

    此外,还有另外一种说法。在C语言中有指针的概念,而指针数组标号实际上是一个偏移量而不是计数作用。例如对于指针p,第N个元素是*(p+N),指针指向数组的第一个元素就是*(p+0),

    一些现代语言为什么仍然使用这种做法

    上文中提到的为了计较分秒的编译时间而使用0下标数组,在硬件飞速发展的今天显然是不必要的。那么为什么一些新兴语言,如Python依然选择以0作为数组第一个元素呢?难道也是历史原因?对于这个问题,Python的作者Guido van Rossum也有自己的答案。这里大致概括一下作者的用意:从0开始的半开放数组写法在表示子数组(或者子串)的时候格外的便捷。例如:a[0:n]表示了a中前n个元素组成的新数组。如果我们使用1开始的数组写法,那么就要写成a[1:n+1]。这样就显得不是很优雅。那么问题来了,Python数组为什么使用半开放,即[m,n)左闭合右开发的写法呢?这个理解起来就比较简单,读者可以参考http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF作为扩展阅读。下面摘录一段Python作者的原话:

    Using 0-based indexing, half-open intervals, and suitable defaults (as Python ended up having), they are beautiful: a[:n] and a[i:i+n]; the former is long for a[0:n].

    Using 1-based indexing, if you want a[:n] to mean the first n elements, you either have to use closed intervals or you can use a slice notation that uses start and length as the slice parameters. Using half-open intervals just isn't very elegant when combined with 1-based indexing. Using closed intervals, you'd have to write a[i:i+n-1] for the n items starting at i. So perhaps using the slice length would be more elegant with 1-based indexing? Then you could write a[i:n]. And this is in fact what ABC did -- it used a different notation so you could write a@i|n.(See http://homepages.cwi.nl/~steven/abc/qr.html#EXPRESSIONS.)

    总结

    从0标号的数组传统,沿用了这么长时间的原因主要列举如下:

    在计算资源缺乏的过去,0标号的写法可以节省编译时间

    现代语言中0标号可以更优雅的表示数组字串

    在支持指针的语言中,标号被视作是偏移量,因此从0开始更符合逻辑

    展开全文
  • 参考答案如下中数组元穆勒认为因果关系有个要素素下始近代哲学是笛卡尔宇宙演化说的根据。()笛卡尔将“凡是我们领会得十分清楚、中数组元十分分明的东西都是真实的”这一条订为总则。笛卡尔将数学理性和逻辑理性相...

    参考答案如下

    中数组元穆勒认为因果关系有几个要素

    素下始近代哲学是笛卡尔宇宙演化说的根据。()

    笛卡尔将“凡是我们领会得十分清楚、中数组元十分分明的东西都是真实的”这一条订为总则。

    笛卡尔将数学理性和逻辑理性相结合,素下始产生了直观演绎法。

    笛卡尔对普遍怀疑进行了论证,中数组元其四个证明分别是:人的感觉的证明、睡梦的证明、上帝可能是骗人的证明和()。

    素下始笛卡尔对()的证明是其整个形而上学体系的一个起点。

    中数组元笛卡尔引入天文学的是发展的观点。()

    素下始笛卡尔将发展的观点引入天文学。()

    中数组元笛卡尔所确信的“毕竟有物存在”的这个“物”就是“我思”之“我”。

    笛卡尔把《论世界》的三个附录整理成《谈谈方法》发表,素下始这三个附录分别是:《屈光学》、《气象学》和()。

    碘值越大,中数组元表明油脂中不饱和脂肪酸的含量越高或不饱和程度越高。( )

    碑刻是传承历史的重要载体,素下始是珍贵的历史文化遗产

    中数组元碑刻非文本解读的技巧主要有

    碘摄入不足会导致甲状腺功能低下,素下始下列哪项不是该病的表现?( )

    中数组元碘缺乏与过多都会增加甲状腺肿瘤的危险性。

    本文章来自话题:尔雅习题

    举报文章

    展开全文
  • 数组是在内存中存储相同数据类型的连续的空间声明一个数组就是在内存空间中划出一串连续的空间Java中的数组数组名代表的是连续空间的首地址通过首地址可以依次访问数组所有元素元素在数组中的排序叫做下标从开始...

    数组是在内存中存储相同数据类型的连续的空间

    声明一个数组就是在内存空间中划出一串连续的空间Java中的数组

    数组名代表的是连续空间的首地址

    通过首地址可以依次访问数组所有元素

    元素在数组中的排序叫做下标从零开始Java数组

    数组的使用

    数组长度一旦声明,不可改变不可追加

    声明一个int类型的数组

    int[ ] arr;   或int arr[ ]

    给数组分配空间

    arr=new int[5];

    给数组赋值

    arr[0]=1;      0代表的是数组的第1个元素 ,元素下标为0

    arr[1]=1;      1代表的是数组的第2个元素 ,元素下标为1

    访问数组数据 ,使用数组下标访问       c=arr[4];

    数组声明缩写

    Java数组

    int[ ] arr={12,3,4,8,5,6,6,7,8,8,9,8};

    int [ ] arr1=new int[ ]{12,3,4,8,5,6,6,4};

    new int[ ]的[ ]一定不能放内存大小

    使用循环给数组赋值

    示例为

    int[ ] arr=new int[5];

    for (int i = 0; i < arr.length; i++) {

    System.out.println("数组第"+(i+1)+"个值为"+i);

    }

    7eb3b645486afc99c0dbba6733a30a54.png

    使用循环遍历给数组赋值,输出数组

    实例为

    int[ ] arr={1,3,6,5,6,7,84,55,5};

    for (int num:arr) {

    System.out.println(num);

    }

    显示结果为

    729af929e016a2bcb01fb178cda2fdda.png

    数组中常用来排序的两种方法

    冒泡排序

    例子:

    public static void main(String[] args) {

    实现学生成绩排序并显示学生成绩列表

    int [   ] arr = {78,89,67,98,90,56,88};

    N个数的数组,需要比较N-1轮

    for(int i=0; i

    for(int j=i; j

    if(arr[i]>arr[j]){

    int temp = arr[j];

    arr[j] = arr[i];

    arr[i] = temp;

    }

    }

    }

    冒泡排序   升序排列

    for(int i=0; i

    for(int j=0; j

    if(arr[j]>arr[j+1]){

    int temp = arr[j];

    arr[j] = arr[j+1];

    arr[j+1] = temp;

    }

    }

    }

    二分法排序

    二分法查找

    int start = 0;      // 默认起始坐标

    int end = arr.length-1;     // 默认结尾坐标

    int index = -1;      // 找不到默认index为-1

    while(start<=end){

    int middle = (start+end)/2;     // 计算中间下标

    if(num == arr[middle]){

    index = middle;

    break;

    }

    if(num > arr[middle]){

    start = middle + 1;

    }

    if(num < arr[middle]){

    end = middle - 1;

    }

    } System.out.println(index);

    }

    }

    下面是一些实例.

    ① 做一个购物清单,手动输入金额,输出是要显示总金额

    Scanner in=new Scanner( System.in);

    double sum=0;

    double[ ] arr=new double[5];

    for (int i = 0; i < arr.length; i++) {

    System.out.print("请输入第"+(i+1)+"笔购物金额:");

    arr[i]=in.nextDouble();

    sum+=arr[i];

    }

    System.out.println("序号\t\t 金额");

    for (int i = 0; i < arr.length; i++) {

    System.out.println((i+1)+"\t\t"+arr[i]);

    }

    System.out.println("总金额:"+sum );

    }

    显示结果为

    5684628d2989f61c56cd47a12a34bc3e.png

    ②输入四家店的价格,并找出最小价格

    Scanner in=new Scanner(System.in);

    int[] arr=new int[4];

    System.out.println("请输入四家店的价格");

    for (int i = 0; i <4; i++) {

    System.out.print("第"+(i+1)+"店的价格为:");

    arr[i]=in.nextInt();

    }

    for (int j = 0; j < arr.length-1; j++) {

    if (arr[j]

    arr[j+1]=arr[j];

    }else {

    arr[j+1]=arr[j+1];

    }

    }System.out.println("最低价格是:"+arr[3]);

    }

    显示结果为

    efd110a62561e1b0b11145aad31cda68.png

    ③将一个数组从小到大排列

    int[] arr={56,45,99,82,91,81};

    int max;

    int m;

    for (int i = 0; i < arr.length-1; i++) {

    for (int j = 0; j < arr.length-1-i; j++) {

    if (arr[j]>arr[j+1]) {

    int temp=arr[j];

    arr[j]=arr[j+1];

    arr[j+1]=temp;

    }

    }

    }

    for (int a: arr) {      System.out.println(a);                 }   }}

    显示结果为

    5925834e4d93497469b1c0d4e4d2d77c.png

    ④输入一个数字,在数组中查找,若有输出下标,若没有输出-1

    Scanner in=new Scanner(System.in);

    int[] arr={12,34,46,68,32,35,75,48,25};

    System.out.println("输入一个数字");

    int sz=in.nextInt();

    for (int i = 0; i < arr.length; i++) {

    if (sz==arr[i]) {

    System.out.println("数字下标为"+i);

    return;

    }

    }

    System.out.println("-1");

    显示结果为

    9b015503b8915a910195496c5810761c.png

    ⑤编写JAVA程序,实现两个数组的合并,并按升序排列合并后的数组       假定现有两个数组,分别为:        int[ ] arr1={3, 1, 23};        int[ ] arr2={27, 7, 2};       设计程序,将两个数组合并成一个数组,并按升序排列合并后的数组,输出合并前和合并后的数组信息

    int[ ] arr1 = {3, 1, 23};

    int[ ] arr2 = {27, 7, 2};

    int[ ] arr = new int[arr1.length+arr2.length]; // 1. 声明一个数组,长度等于两个数组的长度和

    for(int i=0; i

    arr[i] = arr1[i];

    }

    for(int i=0; i

    arr[arr1.length+i] = arr2[i];

    }

    for(int i=0; i

    for(int j=0; j

    if( arr [ j ]>arr[ j+1 ]){

    int temp = arr[ j ];

    arr [ j ] = arr[ j+1 ];

    arr[ j+1 ] = temp;

    }

    }

    }

    System.out.println(Arrays.toString(arr));

    显示结果为

    63c2950cba2bcffa6b6fc6b685988e61.png

    ⑥用数组,判断一个数字,是不是回文数。

    System.out.print("请输入一个数组:");

    Scanner in = new Scanner(System.in);

    long num = in.nextLong();

    long old = num; // 暂存num

    int count = 0; // num有几位,定义一个几位的数组。 求出num的位数

    while(num>0){

    num /= 10;

    count++;

    }

    int[] arr = new int[count];

    count = 0; // 不断取出数字的每一位,依次放入数组中

    while(old>0){

    arr[count] = (int)old % 10;

    old /= 10;

    count ++;

    }

    for(int i=0,j=arr.length-1; i<=j ; i++,j--){ // 依次比较数组的首尾。 有任意一位不相等,就不是回文数

    if(arr[i] != arr[j]){

    System.out.println("不是回文数");

    return;

    }

    }

    System.out.println("是回文数");

    显示结果为

    1d372f276eca65c89864ed3280139d52.png

    ⑦      输入数组,最大的与第一个元素交换,最小的与最后一个元素交换,输出数组

    // Scanner in=new Scanner(System.in); //设置输入数组

    // int [] arr;

    // System.out.println("输入数组");

    // for (int i = 0; i < arr.length; i++) {

    // int arr[i]=in.nextInt();

    int [ ] arr = {5,3,7,1,0,6,9,2};

    int max = arr[0] , maxIndex = 0; // 找出最大元素的下标

    for(int i=0; i

    if(max < arr[i]){

    max = arr[i];

    maxIndex = i;

    }

    }

    if( maxIndex != 0 ){

    int temp = arr[0];

    arr[0] = arr[maxIndex];

    arr[maxIndex] = temp;

    }

    int min = arr[0] , minIndex = 0; //找出最小元素的下标

    for(int i=0; i

    if(min > arr[i]){

    min = arr[i];

    minIndex = i;

    }

    }

    if(minIndex != (arr.length-1)){

    int temp = arr[arr.length-1];

    arr[arr.length-1] = arr[minIndex];

    arr[minIndex] = temp;

    }

    System.out.println(Arrays.toString(arr));

    }

    显示结果为

    3acaaf6eed2dede1d12815ab0a13ee71.png

    展开全文
  • 题目:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(第0个开始,到第3个为止)。给一个数组,返回它的最大连续子序列的和解题思路​万物皆可使用暴力法,暴力法还是比较容易的,O(n^2)的时间复杂度,我是满足的,...

    题目:

    {6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组,返回它的最大连续子序列的和

    解题思路

    ​万物皆可使用暴力法,暴力法还是比较容易的,O(n^2)的时间复杂度,我是满足的,但是面试官显然不满足,使用动态规划可以是复杂度到O(n)。

    ​博主看了几篇关于最大连续子序列的和的博客,发现都是上来给出状态方程:

    max( dp[ i ] ) = getMax( max( dp[ i -1 ] ) + arr[ i ] ,arr[ i ] )

    ​这谁顶的住啊,尤其是像博主这种算法能力很差的同学。

    ​首先我们需要了解dp[i]到底是个啥,经过博主的不懈努力,终于发现dp[i]就是以数组下标为i的数做为结尾的最大子序列和,注意是以i为结尾,比如说现在有一个数组{6,-3,-2,7,-15,1,2,2},为了不搞,我们就下标以1开始,dp[3]就是以-2为结尾的,那么显然dp[3]的最大值就是1咯(6,-3,-2),dp[4]要以7结尾那么以7结尾的子序列最大和就是8(6,-3,-2,7)。

    ​知道dp[i]是啥后,现在我们开始细细品一下上面这个递推式,求dp[i]的时候是不是有两种可能,要么就是像上面的dp[4]一样,dp[3]求出来是1了,再加上自己array[4]是最大的,那么还有一种可能就是说如果dp[3]我求出来是-100,那如果我也是dp[3]+array[4]的话是-93,这时候dp[3]反而是累赘,最大就是自己(因为前面定义了必须以i为结尾,也就说必须以7结尾)。

    代码实现

    /**

    * dp dp(i)=max(dp(i-1)+array[i],array[i])

    * {6,-3,-2,7,-15,1,2,2},

    * @author dingyu

    */

    public class T29 {

    public int FindGreatestSumOfSubArray(int[] array) {

    //max就是上面的dp[i]

    int max = array[0];

    //因为这个dp[i]老是变,所以比如你dp[4]是8 dp[5]就变成-7了,所以需要res保存一下

    int res = array[0];

    for (int i = 1; i < array.length; i++) {

    max = Math.max(max + array[i], array[i]);

    res = Math.max(res, max);

    }

    return res;

    }

    }

    展开全文
  • 第二十二讲——JAVA数组数组就是相同类型(比如int,byte...)数据的有序集合每一个数据是整个数组中的一个组成元素调用元素,要通过下标来调用(10,11,12,13,14(下标0开始个就是第n个标))01—数组创建和...
  • 1.1、ArrayList概述1)ArrayList是可以动态增长和缩减的索引序列,它是基于数组实现的List类。2)该类封装了一个动态再分配的Object[]数组,每一个类对象都有一个capacity属性,表示它们所封装的Object[]数组的长度,...
  • java数组

    2019-11-09 09:23:21
    java数组 1.为什么要用数组 有时候需要存储或处理一系列数据 2.什么时候用数组 当数据量很大时 3.当操作数组的时候,什么时候用循环 ...数组的标:数组的下标0开始的 数组的长度:length 数组做方法参数...
  • 常用数据类型基本数据类型一般就是数值、字符串、布尔数值——int、double、long……字符串——String布尔——boolean然后就是一些容器,数组、集合……数组——Arrays集合——List、ArrayList……而在这些基础上,...
  • public static void insertSort(int[] array) { //插入排序 ... // 此循环1开始,就是将0下标的元素当做一个参照  for (int i = 1; i &lt; length; i++) {  //if (array[i] &lt; array[i - 1]) ...
  • Java数组中的一维数组

    2020-05-04 10:30:01
    标识符、数组元素、元素下标0开始)、元素类型 数组的使用 1.声明: 告诉计算机数据类型,声明数组时不规定长度 2.分配空间: 告诉计算机分配个连续空间数据元素类型不同,元素初始值不同int默认为0、double...
  • 此时数组已经创建完毕了,数组的长度为3,下标从0开始,2结束。默认所有元素都为0,如果类型是object的话默认元素都为null。这个和对象的创建是一样的,初始化后的对象如果不被赋值他就默认为null,也就是没有指向堆...
  • ③元素下标0开始数组中的每个元素都可以通过下标来访问。④元素类型:数组中所有元素都要是相同的类型。>注意:数组组长不变,避免数组越界。看一下创建一个数组个小步骤:①声明数组 int类型 int...
  • 规则如下:将班里的N个人围城一圈,顺序编号,第一个人开始报数(1到3报数),凡报到3的人退出圈子,然后下一个人重新开始,最后留下的那个人就被选为班长,请问按照这个规则,选出的班长是原来编号为第号的...
  • 作者 | 漫话编程来源 | 漫话编程当我们想要写一...还有,当我们定义数组的时候,在常见的C语言、Java、Python等语言中,都是使用下标0来表示第一个元素的。0开始更优雅在《为什么程序员喜欢使用0 ≤ i < 10这种...
  • 先看再点赞,给自己一点思考的时间,思考过后请毫不犹豫微信...关于 Java 基础、Java 面向对象编程、Java 字符串、Java 数组等方面的知识点已经可以告一段落了,小伙伴们可以在「沉默王二」公众号后台回复「小白」...
  • 面试官Q1:可以手写一个...这一节,我们不看源码,我们想想如何简单的实现ArrayList个基本方法?确定数据结构我们知道,ArrayList中无论什么数据都能放,是不是意味着它是一个Object类型,既然是数组,那么是...
  • 当我们向ArrayList的对象中增加一个对象的时候,Java会去检查ArrayList对象,确保底层的数组中有足够的容量来存储这个新的对象。如果容量不够增加新元素的话,那就会新建一个长度更长的数组(1....
  • ArrayList 可能是 Java 数据结构中最简单的一种了,即使一个非 Java 程序员可能也知道这个数据结构,因为所有的语言中都有这样的类似的数据结构。但是在面试中很多人又对它又爱又恨,你真的了解 ArrayList 吗?一、...
  • 数组1、数组的个重要特征连续存储空间(方便查找)数组长度固定(灵活性差)数组中只能存放相同的数据类型数组下标从0开始计算2、数组的声明定义//定义int型数组ary0并声明长度为4int ary0[] = new int[4];//定义int型...
  • 数组1、数组的个重要特征连续存储空间(方便查找)数组长度固定(灵活性差)数组中只能存放相同的数据类型数组下标从0开始计算2、数组的声明定义//定义int型数组ary0并声明长度为4int ary0[] = new int[4];//定义int型...
  • java 中的数组

    2017-01-15 14:59:32
    下标0 开始。一般的一维数组看做是是一个向量,因为集合是没有次序的概念的,也不允许有重复的元素。使用集合的时候,只需判定一个元素是不是属于某个集合,并不强调这个元素在集合中所处的位置或次序。在数组中...
  • 1: System.arraycopy(src, srcPos, dest, destPos, length); arc数组中的第srcpos位置的数开始复制length个数到dest数组的destpos开始。...将一个原始的数组original,从下标from开始复制,复制到上标to,生成一...
  • 数组 1、数组的个重要特征 ...数组下标从0开始计算 2、数组的声明定义 //定义int型数组ary0并声明长度为4 int ary0[] = new int[4]; //定义int型数组ary1同时赋初始值 int ary1[] = new int[]{1,2,...
  • Java中对数组的介绍

    2018-05-05 12:15:49
    数组元素:像数组中存储的元素值数组下标0开始定义数组种方式:数据类型 [] 数组名 (推荐使用) 或 数据类型 数组名[]一维数组初始化的方法:数据类型 [] 数组名=new 数据类型[数组长度]; (推荐使用...
  • Java篇--数组

    2020-06-08 19:40:01
    数组的四要素: 数组名称:用来区分不同的数组 数组元素:向数组中存放的数据 元素类型:数组元素的数据类型 元素下标数组元素的编号,也称为索引,0开始,通过下标来访问数组元素 2. 基本用法 步骤:1. 声明...
  • 数组

    2020-12-21 22:03:43
    数组 1.什么是数组? 1)具有相同数据类型的数据的集合 ...4)下标从0开始数组的长度-1结束 5)数组可以存储重复元素 4.Java有集中数组(Reference Type)? 1)一维数组Java的一维数组的定义有种形式?
  • java中去除数组中重复元素的方法

    千次阅读 2020-07-21 20:08:01
    首先建立一个与原数组等长的标记数组flag[],它的下标与原数组下标相同,而我们只要改变它的值,就可以知道第个元素是重复的 遍历原数组 内层也遍历原数组,如果arr[i] == arr[j] ,也就是外层循环到的元素与内层...
  • 索引是0开始的; 数组的基本要素 标识符:数组名称 数组元素:就是数组中存在放的数据 元素下标:对数组元素的进行编号,通过下标访问数组元素 数组的类型:数组中元素的数据类型 数组的定义的种...

空空如也

空空如也

1 2 3 4 5
收藏数 81
精华内容 32
关键字:

java数组下标从几开始

java 订阅