精华内容
下载资源
问答
  • 1.概述 ①Java语言中的数组是一种引用数据类型。不属于墓本数据类型。数组的父类是 object ②数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合。...⑦数组的分类:一维数组、二维数组、三

    1.概述

    ①Java语言中的数组是一种引用数据类型。不属于墓本数据类型。数组的父类是 object
    ②数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合。)数组:面意思是一组数据
    ③数组当中可以存基本数据类型的数据,也可以存引用数据类型的数据。
    数组因为是引用类型,所以数组对象是堆内存当中。(数组是存储在堆当中的)
    数组当中如果存的是java对象的话,实际上存的是对象的引用(内存地址)
    ⑥数组一且创建,在java中规定,长度不可变。(数组长度不可变)
    ⑦数组的分类:一维数组、二维 数组、三维数组、多维数组…(一维数组较多,二维数组偶尔使用!)
    所有的数组对象都有length属性(java自带的),用来获取数组中元素的个数。
    ⑨java中的数组要求数组中元素的类型统一。比如int类型数组只能存储nt类型, Person类型数组只能存 Person类型.(数组中存储的元素类型统一)
    ⑩数组在内存方面存的时候,数组中的元素内存地址(储存的每一个元素部是有规则的挨着排列的)是连续的。内存地址连续,数组存储元素的特点(特色)。数组实际上是一种简单的数据结构。
    所有的数组都是拿第一个小方框的内存地作为整个数组对的内存地址。(数组中首元素的内存地址作为整个数组对象)
    数组中每一个元素部是有下标的,下标从0开始,以1递增。最后一个元素的下标是: length-1
    下标非常重要,因为我们对数组中元素进行存取的时候,都需要通过下标来进行

    13.数组这种数据结构的优点和缺点是什么
    缺点:
    第-:由于为了保证数组中每个元素的内存地址连续,所以在数组上随机删除或者增加元素的时候,
    效率较低,因为随机增删元素会涉及到后面元素绕一向前或者向后位移的操作。
    第二:数组不能存大数据量,为什么?
    因为很难在内存空间上找到一块特别大的连续的内存空间。

    2.定义一维数组

    一.一维数组的声明格式:

    数组元素的类型[] 变量名称
    int[] array;
    double[] array;
    boolean[] array3
    String[] array;
    Object[] arrays

    二.初始化一个一维数组

    包括两种方式:静态初始化一维数组,动态初始化一维数组。
    静态初始化语法搭式
    int[] array={100,2100,300,55};
    动态初始化语法格式
    int[] array= new int[5];//这里的5表示数组的元素个数。
    //初始化一个5个长度的int类型数组,每个元素默认0
    String[] names= new String[6];//初始化6个长度的String类型数组,每个元素默认篇null。

    三.实例

    数组名.length的方式来获得数组的长度,即数组元素的个数,所有数组都有length属性
    array.length

    public class ArrayTest01 {
        public static void main(String[] args) {
            int[] a=new int[4];
            int[] a2={10,20,30,34};
            System.out.println(a.length);
            System.out.println(a2[0]);
            System.out.println(a2[a2.length-1]);
            //数组遍历
            for(int i=0;i<a2.length;i++){
                System.out.println("正序"+a2[i]);
            }
            for (int i= a2.length-1;i>=0;i--){
                System.out.println("倒序"+a2[i]);
            //System.out.println(a2[a.length]);ArrayIndexOutOfBoundsException    
            //数组下标越界异常
            }
        }
    }
    
    

    4
    10
    34
    正序10
    正序20
    正序30
    正序34
    倒序34
    倒序30
    倒序20
    倒序10

    四.方法的参数是数组

    public class ArrayTest03 {
        public static void main(String[] args) {
            int[] x={1,20,30,39};
            ArrayTest03.printArray(x);
            String[] str={"abc","asd","fuck"};
            ArrayTest03.printArray(str);
            System.out.println("---------------");
            int[] y=new int[4];
            printArray(y);
            System.out.println("*******************");
            String[] str2=new String[4];
            printArray(str2);
            System.out.println("******************");
            printArray(new int[3]);
           // printArray({"fuck","wtf","son of bitch"});java: 非法的表达式开始
            printArray(new String[]{"fuck","wtf","son of bitch"});
    
        }
        public static void printArray(int[] args){
            for (int i=0;i<args.length;i++){
                System.out.println(args[i]);
            }
        }
        public static void printArray(String[] args){
            for (int i=0;i<args.length;i++){
                System.out.println(args[i]);
            }
        }
    }
    
    

    1
    20
    30
    39
    abc
    asd
    fuck


    0
    0
    0
    0


    null
    null
    null
    null


    0
    0
    0
    fuck
    wtf
    son of bitch

    五.main方法的String数组

    如果配置了argue环境变量,默认则是0
    在这里插入图片描述

    public class ArrrayTest05 {
        public static void main(String[] args) {
            printArray(args);
            String[] str=new String[0];
            printArray(str);
        }
        public static void printArray(String[] args){
            System.out.println(args.length);
            for (int i=0;i< args.length;i++){
                System.out.println(args[i]);
            }
        }
    }
    

    3
    abc
    fcd
    sfd
    0

    六.数组中存储引用数据类型

    public class ArrayTest07 {
        public static void main(String[] args) {
            Animal[] animals=new Animal[2];
     /*       System.out.println(animals[0]);
            System.out.println(animals[1]);*/
    
            animals[0]=new Bird();
            animals[1]=new Cat();
            for (int i=0;i< animals.length;i++){
               if(animals[i] instanceof Bird){
                  Bird bird=(Bird)animals[i];
                  bird.Birdfly();
               }
               if (animals[i] instanceof Cat){
                   Cat cat=(Cat)animals[i];
                   cat.catchMouse();
               }
    
            }
           /* Cat c=new Cat();
            Bird b=new Bird();*/
    /*        Animal[] animals1=new Animal[]{new Bird(),new Cat()};
            for (int i=0;i< animals1.length;i++){
                animals1[i].move();
            }*/
        }
    }
    class Animal{
        public void move(){
            System.out.println("Animal move");
        }
    
    }
    class Cat extends Animal{
        public void move(){
            System.out.println("Cat move");
        }
        public void catchMouse(){
            System.out.println("Catch mouse");
        }
    }
    class Bird extends Animal{
        public void move(){
            System.out.println("Bird move");
        }
        public void Birdfly(){
            System.out.println("bird fly");
        }
    }
    

    各种数据类型在内存的存储方式

    在这里插入图片描述

    七.数组拷贝

    关于一维数组的扩容。
    在java开发中,数组长度一旦确定不可变,那么数组满了怎么办?
    数组满了,需要扩容
    java中对数组的扩容是先新建一个大容量的数组,然后将小容量数组中的数据一个一个持贝到大数组当中。
    结论:数组扩容效率较低。因为涉及到贝的问题。所以在以后的开发中请注意:尽可能少的进行数组的拷贝,可以在创建数组对象的时候预倍计以下多长合适,最好预估准确,这样可以减少数组的扩容次数。提高效率
    System类的方法

    语法:

    System.arraycopy(被拷贝的数组对象,被拷贝数组的起始下标,拷贝的数组对象,拷贝数组对象的起始下标,需拷贝的对象数组长度)

    public class ArrayTest08 {
        public static void main(String[] args) {
            int[] x={111,23,32};
            int[] y=new int[6];
            System.arraycopy(x,1,y,1,2);
            for (int i=0;i<y.length;i++){
                System.out.println(y[i]);
            }
            Object[] objs=new Object[]{"abc","cdf","fas"};
            Object[] newObjs=new Object[5];
            System.arraycopy(objs,0,newObjs,0,objs.length);
            for (int i=0;i<newObjs.length;i++){
                System.out.println(newObjs[i]);
            }
        }
    
    }
    

    在这里插入图片描述

    八.二维数组

    一.概述

    关于java中的二维数组
    ①二维数组其实是一个特殊的一维数组,特殊在这个一维数组当中的每一个元素是一个一维数组。
    ②三维数组是什么?
    三维数组是一个特殊的二维数组,特殊在这个二维数组中每一个元素是一个一维数组
    实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。
    ③二维数组静态初始化
    int[][] array={{1,1,1},{2,3,4,5},{0,0,0,0}};

    public class ArrayTest09 {
        public static void main(String[] args) {
            //二位数组初始化
            int[][] x = {{111, 21},
                    {24334, 3, 34, 23},
                    {24, 254, 345}
            };
            //二维数组length属性
            System.out.println(x.length);
            System.out.println(x[0].length);
            System.out.println(x[1].length);
            System.out.println(x[2].length);
            System.out.println("***************************************");
            //二维数组的元素访问
            int[] y = x[0];
            int y1=y[0];
            System.out.println(y1);//推导过程
            System.out.println(x[0][0]);
            System.out.println(x[2][2]);
           // System.out.println(x[2][3]);java.lang.ArrayIndexOutOfBoundsException
           System.out.println("***************************************");
           //二维数组的遍历
           for(int i=0;i< x.length;i++){
               for (int j=0;j<x[i].length;j++){
                   System.out.print(x[i][j]+" ");
               }
               //换行
               System.out.println();
           }
        }
    }
    
        }
    }
    
    

    3
    2
    4
    3


    111
    111
    345


    111 21
    24334 3 34 23
    24 254 345

    二.方法的参数是一个二维数组

    package com.array;
    
    public class ArrayTest12 {
        public static void main(String[] args) {
            //动态初始化
            int[][] a=new int[3][4];
            for(int i=0;i< a.length;i++) {
                for (int j = 0; j < a[i].length; j++) {
                    System.out.print(a[i][j] + " ");
                }
                System.out.println();
            }
            System.out.println("*****************");
            int[][] a1={
                {12,23,34,1},
                {124,2,78,90},
                {12,32,32,43}
            };
            printArray(a1);
        }
        public static void printArray(int[][] x){
            for(int i=0;i< x.length;i++) {
                for (int j = 0; j < x[i].length; j++) {
                    System.out.print(x[i][j] + " ");
                }
                System.out.println();
            }
        }
    }
    

    三.二维数组是一个引用数据类型

    package com.bjpowernode.hotel;
    
    public class Room {
        private int no;
        private boolean status;
        private String type;
    
        public Room() {
        }
    
        public Room(int no, boolean status, String type) {
            this.no = no;
            this.status = status;
            this.type = type;
        }
    
        public int getNo() {
            return no;
        }
    
        public void setNo(int no) {
            this.no = no;
        }
    
        public boolean isStatus() {
            return status;
        }
    
        public void setStatus(boolean status) {
            this.status = status;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
        public boolean equals(Object obj){
            Room room=(Room)obj;
            return this.no==room.no;
        }
        public String toString(){
            return no+" "+(status?"有房":"空房")+" "+type;
        }
    
    }
    class roomtest{
        public static void main(String[] args) {
           hotel hotels=new hotel();
           hotels.print();
        }
    }
    
    package com.bjpowernode.hotel;
    
    public class hotel {
        private Room[][] rooms;
        public hotel(){
            rooms=new Room[3][10];
            for (int i=0;i<=rooms.length-1;i++){
                for (int j=0;j<=rooms[i].length-1;j++){
                    if(i==0){
                        rooms[i][j]=new Room(100*(i+1)+j+1,true,"标准间");
                    }
                    if(i==1){
                        rooms[i][j]=new Room(100*(i+1)+j+1,true,"单人间");
                    }
                    if(i==2){
                        rooms[i][j]=new Room(100*(i+1)+j+1,true,"双人间");
                    }
                }
            }
        }
        public void print(){
            for (int i=0;i<=rooms.length-1;i++){
                for (int j=0;j<=rooms[i].length-1;j++){
                    System.out.print(rooms[i][j]);
                }
                System.out.println();
            }
        }
    
    }
    

    3.Arrays工具类

    2.2、算法实际上在java中不需要精通,因为java中已经封装好了,要排序就调用方法就行。例如:java中提供了一个数组工具类
    java.util. Arrays
    Arrays是一个工具类
    其中有一个sort()方法和binarySerach(),可以排序和二分法查找。静态方法,直接使用类名调用就行

    package com.bjpowernode3;
    
    
    import java.util.Arrays;
    
    public class ArraysTest01 {
        public static void main(String[] args) {
            int[] arrs={11,78,4,34,343,33};
            Arrays.sort(arrs);
            for(int i=0;i<arrs.length;i++){
                System.out.println(arrs[i]);
            }
            //二分法查找
           int index= Arrays.binarySearch(arrs,33);
            System.out.println(index);
        }
    }
    

    4
    11
    33
    34
    78
    343
    2
    来自jdk1.8中文文档

    binarySearch
    public static int binarySearch(double[] a,double key)
    使用二进制搜索算法搜索指定值的指定数组。数组必须排序(由 sort(double[])法)进行调用之前。如果它没有排序,结果是不确定的。如果数组包含具有指定值的多个元素,则无法找到一个将被发现的保证。这种方法认为所有的南值是等价的和平等的。 
    参数 
    a -阵列被搜查 
    key -要搜索的价值 
    结果 
    索引的搜索关键字,如果它是包含在数组;否则, (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素大于:关键指标,或 a.length如果数组中的所有元素都小于指定的关键。请注意,这保证返回值将是> = 0,如果和只有一个键被发现。 
    

    简单解释,binarySerach(查找数组名,查找值),找到则返回对应数组下标,没找到返回-1

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

    一维数组

    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数组:一维数组

    2021-02-09 14:46:58
    文章目录数组:Array1、数组相关基础知识2、数组的优缺点一维数组1、怎样声明一个一维数组2、怎样初始化一个一维数组呢?3、对一维数组中的元素访问4、 一维数组的遍历5、静态存储Object类6、动态初始化一维数组7、...

    数组:Array

    1、数组相关基础知识

    • 1、Java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。
    • 2、数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合)。
      数组:字面意思是“一组数据”。
    • 3、数组当中可以存储基本数据类型的数据,也可以存储“引用数据类型” 的数据。
    • 4、数组因为是引用类型,所以数组对象堆内存当中的。(数组是存储在堆当中的)。
    • 5、数组当中如果存储的是“java对象” 的话,实际上存储的是java对象的“引用(内存地址)”,数组不能直接存储java对象。
    • 6、数组的分类:一维数组、二维数组、三维数组、多维数组…(一维数组较多,二维数组偶尔使用)。
    • 7、数组一旦创建,在java规定,长度不可变。(数组长度不可变)。
    • 8、所有数组对象都有length属性(java自带的),用来获取数组中元素的个数。
    • 9、java中的数组要求数组中的元素类型统一。
    • 10、数组在内存方面存储的时候,数组中的元素内存地址(存储的每一个元素都是有规则的挨着排列的)是连续的。内存地址连续。这是数组存储元素的特点。数组实际上是一种简单的数据结构。
    • 11、所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。(数组中首元素的内存地址作为整个数组对象的内存地址)
    • 12、数组中的每一个元素都是有下标的,下标从0开始,以1递增。最后一个元素的下标:length - 1
      下标非常重要,因为我们对数组中的元素进行“存取”的时候都需要下标;来进行。

    2、数组的优缺点

    优点:

    查询、检索某个下标上的元素时效率极高。可以说查询效率最高的一个数据结构。

    为什么检索效率高?

    • 第一:每一个元素的内存地址在空间存储上是连续的。
    • 第二:每一个元素类型相同,所以占用空间大小一样。
    • 第三:如果知道一个元素内存地址,知道每一个元素占用空间大小,又知道下标,所以通过一个数学表达式就可以计算出某个下标上的元素的内存地址。直接通过内存地址定位元素,所以数组的检索效率是最高的。

    缺点:

    • 第一:由于为了保证数组中每个元素的内存地址连续,所以在数组上随即删除或者增加元素的时候效率较低,因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
    • 第二:数组不能存储大量数据,因为很难在空间上找到一块特别大的连续的内存

    注意:对于数组中最后一个元素的增删是没有效率影响的

    一维数组

    1、怎样声明一个一维数组

    语法格式:
    int[] array;
    double[] array;
    boolean[] array;
    String[] array;
    Object[] array;

    2、怎样初始化一个一维数组呢?

    包括两种方式:静态初始化一维数组、动态初始化一维数组

    静态初始化一维数组int[] array = {100,200,300};String[] str = {"as","cs" ,"ds"};
    也可以使用 int array[] = {1,2,3},这是C++风格,不建议在java中使用

    动态初始化一维数组
    int[] array = new int [5]; 这里的5表示数组元素个数,初始化一个5个长度的int类型数组,每个元素默认值为0

    String[] names = new String[6]; 初始化6个长度的String类型数组,每个元素默认值null

    3、对一维数组中的元素访问

    public class ArrayTest01 {
        public static void main(String[] args) {
            int[] a = {1,2,3,4,5};
           
           //取(读)
            System.out.println(a.length);
            System.out.println("第一个元素是" + a[0]);
            System.out.println("最后一个元素是" + a[4]);
            System.out.println("最后一个元素是" + a[a.length - 1]);
    
    		//存(改)
            a[0] = 0;//把第一个元素修改
            
            a[a.length-1] = 999;//把最后一个元素修改
            
            System.out.println("第一个元素是" + a[0]);
            System.out.println("最后一个元素是" + a[4]);
            System.out.println("最后一个元素是" + a[a.length - 1]);
        }
    }
    

    输出结果:
    在这里插入图片描述

    4、 一维数组的遍历

    遍历写法:

    提示:下标越界会出现异常:

           接上面代码
           
            for (int i = 0;i < a.length; i++){
                System.out.println(a[i]);
            }
            
    		//颠倒遍历
            for (int i = a.length - 1;i >= 0; i--){
                System.out.println("颠倒顺序输出-->" + a[i]);
            }
    

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

    5、静态存储Object类

    Object o1 = new Object();
    Object o2 = new Object();
    Object o3 = new Object();
    
    Object[] object= {o1,o2,o3};
    
    /*或
    Object[] object= {new Object(),new Object(),new Object()};
    */
    
    for(int i = 0; i < object.length; i++){
    	System.out.println(object[i]);
    }
    

    6、动态初始化一维数组

    public class ArrayTest {
        public static void main(String[] args) {
           //声明定义一个数组,采用动态初始化的方式创建
            int[] a = new int[4];//创建长度为4的int数组,数组中每个元素的默认值为0
    		
    		//遍历数组
            for (int i = 0; i < a.length; i++){
                System.out.println("数组中的下标为" + i +"的元素是" + a[i]);
            }
    
        }
    }
    

    输出结果:
    在这里插入图片描述

    7、什么时候采用静态初始化方法/动态初始化方法?

    当你创建数组的时候,确定数组中存储哪些具体的元素的时候,采用静态初始化。
    当你创建数组的时候,不确定数组中存储哪些数据,你可以采用动态初始化的方式,预先分配内存空间。

    8、方法的参数为数组

    public class ArrayTest {
        public static void main(String[] args) {
           //调用方法时传一个数组
            int[] a = {1,2,3,4};
            printArray(a);
            
            //不能printArray({1,2,3});没有这个语法
           /* 或
            printArray(new int[] {1,2,3});
            */
        }
    
            public static void printArray(int[] array){
                for (int i = 0; i < array.length; i++) {
                    System.out.println( array[i]);
                }
            }
    }
    

    9、数组中存储引用数据类型

    对于数组来说,实际上只能存储java对象的“内存地址”。数组中存储的每个元素都是“引用”

    提示:不能存放别的引用数据类型

    如果继承该引用数据类型的数据类型可以使用该数组

    public class ArrayTest2 {
        public static void main(String[] args) {
    
            Animal a1 = new Animal();
            Animal a2 = new Animal();
            Animal[] animals = {a1,a2};
            for (int i = 0; i < animals.length; i++){
                animals[i].move();
            }
        }
    }
    
    class Animal{
        public void move(){
            System.out.println("Animal move");
        }
    }
    
    

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

    10、输出数组的方法

    错误示范System.out.println(array);  //这样输出的是数组的首地址,而不能打印出数组数据

    正确写法:
    int[] array= {1,2,3,4,5,6};

    方式一:for循环

    for(int i=0;i<array.length;i++)
    {
    System.out.println(array[i]);
    }
    

    输出为:(自动换行格式的)

    方式二:for each

    for(int a:array)
    System.out.println(a);
    

    输出格式同方式一。

    方式三:Arrays类中的toString方法(注意,是Arrays不是Array,Arrays类位于java.util包下)
    需要导入import java.util.Arrays

    int[] array= {1,2,3,4,5,6};
    System.out.println(Arrays.toString(array));
    

    11、数组扩容

    java中对数组的扩容是:

    先新建一个大容量的数组,然后将小容量数组中的数据一个一个拷贝到大数据当中。

    结论:数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意:尽可能少的进行数组的拷贝。可以在创建数组对象的时候预估计以下多长合适,最好预估准确,这样可以减少数组的扩容次数,提高效率。

    第一种方法,建立一个新的数组,通过for循环来进行拷贝扩容

    int[] b=new int[a.length*2];//a.length 长度;a数组的长度。即数组中数据的个数
    for(int i=0;i<a.length;i++){
    b[i]=a[i];
    }
    System.out.println(Arrays.toString(b));//这个函数就是将数组b进行遍历输出
    //如果不明白遍历什么意思,建议先学习遍历后再来看此篇文章
    

    第二种方法:固定的写法。System.Arrays.copy(a,0,b,0,a.length);

    int[] c=new int[20];
    System.arraycopy(a,0,c,0,a.length);
    //a,需要复制的内容。第一个0(零):在a中开始复制的内容的位置
    //c,要复制的载体,在这里写c就是将a中需要复制的内容赋值给c
    //第二个0(零):在c中开始复制的位置
    //a.length:要复制的元素量
    System.out.println(Arrays.toString©);
    

    方法三:利用函数方法直接扩容

    //原理,利用Arrays中的函数进行扩容
    
    int[] d=Arrays.copyOf(a,22);//此函数的作用就是复制a的值。定义d的长度
    
    // Arrays.copyOf(a,22); a,需要复制的内容(a数组),22:定义d数组的长度
    System.out.println(Arryas.toString(d));
    }
    }
    

    12、数组拷贝

    数组拷贝的方法System.arraycopy( Object src,int srcPos,Object dest, int destPos,int length)

    Object src:源数组
    int srcPos:源数组起点下标
    Object dest:目标数组
    int destPos:目标数组起点下标
    int length:拷贝的源数组的长度

    数组中存储的元素是引用也可以拷贝。且拷贝的是对象的内存地址

    public class ArrayTest3 {
        public static void main(String[] args) {
            int[] src = {1,11,22,33,44};//拷贝源
    
            int[] dest = new int[20];//拷贝目标
    
            for (int i = 0; i < dest.length; i++){
                System.out.print(dest[i]+" ");
            }
            
            System.out.println();
            
            System.arraycopy(src,1,dest,2,2);//进行拷贝
    
            for (int i = 0; i < dest.length; i++){
                System.out.print(dest[i]+" ");
            }
        }
    }
    

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

    展开全文
  • c++一维数组

    2019-07-28 16:43:15
    数组简介 ... 数组是一种基本的数据结构,用于按顺序存储元素的集合。但是元素可以随机存取,因为数组中的每个元素都可以通过数组索引来识别。...这里我们从一维数组开始,它也被称为线性数组。这里...

    数组简介

    转载:https://leetcode-cn.com/explore/featured/card/array-and-string/198/introduction-to-array/768/

    数组是一种基本的数据结构,用于按顺序存储元素的集合。但是元素可以随机存取,因为数组中的每个元素都可以通过数组索引来识别。

    数组可以有一个或多个维度。这里我们从一维数组开始,它也被称为线性数组。这里有一个例子:

    在上面的例子中,数组 A 中有 6 个元素。也就是说,A 的长度是 6 。我们可以使用 A[0] 来表示数组中的第一个元素。因此,A[0] = 6 。类似地,A[1] = 3,A[2] = 8,依此类推。

    #include <iostream>
    
    int main() {
        // 1. Initialize
        int a0[5];
        int a1[5] = {1, 2, 3};  // other element will be set as the default value
        // 2. Get Length
        int size = sizeof(a1) / sizeof(*a1);
        cout << "The size of a1 is: " << size << endl;
        // 3. Access Element
        cout << "The first element is: " << a1[0] << endl;
        // 4. Iterate all Elements
        cout << "[Version 1] The contents of a1 are:";
        for (int i = 0; i < size; ++i) {
            cout << " " << a1[i];
        }
        cout << endl;
        cout << "[Version 2] The contents of a1 are:";
        for (int& item: a1) {
            cout << " " << item;
        }
        cout << endl;
        // 5. Modify Element
        a1[0] = 4;
        // 6. Sort
        sort(a1, a1 + size);
        cout << endl;
        cout << "[Version 2] The contents of v4 are:";
        for (int& item : v4) {
            cout << " " << item;
        }
        cout << endl;
        cout << "[Version 3] The contents of v4 are:";
        for (auto item = v4.begin(); item != v4.end(); ++item) {
            cout << " " << *item;
        }
        cout << endl;
        // 6. modify element
        v4[0] = 5;
        // 7. sort
        sort(v4.begin(), v4.end());
        // 8. add new element at the end of the vector
        v4.push_back(-1);
        // 9. delete the last element
        v4.pop_back();
    }
    }
    

    动态数组

    #include <iostream>
    
    int main() {
        // 1. initialize
        vector<int> v0;
        vector<int> v1(5, 0);
        // 2. make a copy
        vector<int> v2(v1.begin(), v1.end());
        vector<int> v3(v2);
        // 2. cast an array to a vector
        int a[5] = {0, 1, 2, 3, 4};
        vector<int> v4(a, *(&a + 1));
        // 3. get length
        cout << "The size of v4 is: " << v4.size() << endl;
        // 4. access element
        cout << "The first element in v4 is: " << v4[0] << endl;
        // 5. iterate the vector
        cout << "[Version 1] The contents of v4 are:";
        for (int i = 0; i < v4.size(); ++i) {
            cout << " " << v4[i];
        }
        cout << endl;
        cout << "[Version 2] The contents of v4 are:";
        for (int& item : v4) {
            cout << " " << item;
        }
        cout << endl;
        cout << "[Version 3] The contents of v4 are:";
        for (auto item = v4.begin(); item != v4.end(); ++item) {
            cout << " " << *item;
        }
        cout << endl;
        // 6. modify element
        v4[0] = 5;
        // 7. sort
        sort(v4.begin(), v4.end());
        // 8. add new element at the end of the vector
        v4.push_back(-1);
        // 9. delete the last element
        v4.pop_back();
    }
    

    中心索引

    给定一个整数类型的数组 nums,请编写一个能够返回数组“中心索引”的方法。

    我们是这样定义数组中心索引的:数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。

    如果数组不存在中心索引,那么我们应该返回 -1。如果数组有多个中心索引,那么我们应该返回最靠近左边的那一个。

    示例 1:

    输入:
    nums = [1, 7, 3, 6, 5, 6]
    输出: 3
    解释:
    索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11),与右侧数之和(5 + 6 = 11)相等。
    同时, 3 也是第一个符合要求的中心索引。
    示例 2:

    输入:
    nums = [1, 2, 3]
    输出: -1
    解释:
    数组中不存在满足此条件的中心索引。
    说明:

    nums 的长度范围为 [0, 10000]。
    任何一个 nums[i] 将会是一个范围在 [-1000, 1000]的整数。
    ·

    class Solution {
    public:
    	int pivotIndex(vector<int>& nums) {
    		int index = 1;
    		int center_index = -1;
    		if (nums.size()>2)
    		{ 
    		int left = 0,right=0;
    		for (int i = 1; i < nums.size(); i++)
    			right += nums[i];
    		for (int i = 0; i < nums.size(); i++)
    		{
    			if (i != 0)
    			{
    				left += nums[i - 1];
    				right -= nums[i];
    			}
    
    			if (left == right)
    			{
    				center_index = i; break;
    			}
    		}
    		}
    		return center_index;
    	}
    };
    
    

    关键点:注意数组可以为空,左右两边元素个数可以为0;

    至少两倍

    在一个给定的数组nums中,总是存在一个最大元素 。

    查找数组中的最大元素是否至少是数组中每个其他数字的两倍。

    如果是,则返回最大元素的索引,否则返回-1。

    示例 1:

    输入: nums = [3, 6, 1, 0]
    输出: 1
    解释: 6是最大的整数, 对于数组中的其他整数,
    6大于数组中其他元素的两倍。6的索引是1, 所以我们返回1.

    示例 2:

    输入: nums = [1, 2, 3, 4]
    输出: -1
    解释: 4没有超过3的两倍大, 所以我们返回 -1.

    提示:

    nums 的长度范围在[1, 50].
    每个 nums[i] 的整数范围在 [0, 99].

    class Solution {
    public:
    	int dominantIndex(vector<int>& nums) {
    		vector<int> temp = nums;
    		int index = -1;
    		if (nums.size() >= 2)
    		{
    			sort(temp.begin(), temp.end());
    			int size = nums.size();
    			if (temp[size - 1] >= 2 * temp[size - 2])
    				for (int i = 0; i < nums.size(); ++i)
    					if (temp[size - 1] == nums[i])
    					{
    						index = i;
    						break;
    					}
    		}
    		else if (nums.size() == 1)
    			index = 0;
    
    		return index;
    
    	}
    };
    

    关键点:注意数组仅有一个元素和没有元素的情况,利用排序找出最大和次大。

    加一

    给定一个由整数组成的非空数组所表示的非负整数,在该数的基础上加一。

    最高位数字存放在数组的首位, 数组中每个元素只存储一个数字。

    你可以假设除了整数 0 之外,这个整数不会以零开头。

    示例 1:

    输入: [1,2,3]
    输出: [1,2,4]
    解释: 输入数组表示数字 123。
    示例 2:

    输入: [4,3,2,1]
    输出: [4,3,2,2]
    解释: 输入数组表示数字 4321。

    class Solution {
    public:
    	vector<int> plusOne(vector<int>& digits) {
    		for (int i = digits.size()-1; i >= 0; i--)
    		{
    
    			if (i == 0 && digits[i] == 9)
    			{
    				digits[i] = 0;
    				digits.insert(digits.begin(), 1);
    				break;
    			}
    			if (digits[i] < 9)
    			{
    				digits[i]++;
    				break;
    			}
    			else
    				digits[i] = 0;
    		}
    		return digits;
    	}
    	
    };
    

    关键点:
    1、必须通过数组来实现,不能通过int类型的加减法,因为可能存在超大整数。
    2、 进位时需要插入一位

    展开全文
  • 数组学习01 一维数组

    2019-11-27 20:12:54
    以下内容整理自 ...1、 数组简介 数组是一种基本的数据结构,用于按顺序存储元素的集合。但是元素可以随机存取,因为数组中的每个元素都可以通过数组索引来识别。...这里我们从一维数组开始,它也被称...
  • 数组简介-一维数组

    2020-02-04 12:18:18
    这里我们从一维数组开始,它也被称为线性数组。这里有一个例子: A 6 3 8 7 2 9 index 0 1 2 3 4 5 在上面的例子中,数组 A 中有 6 个元素。也就是说,A 的长度是 6 。我们可以使用 A[0] 来表示数...
  • 20.1 一维数组

    2021-05-11 22:38:25
    数组学习: 1.数组的特点 数组是引用数据类型,所以数组对象(动态初始化使用new关键字)是存放在堆内存中的。...数组分为:一维数组,二维数组,多维数组… 数组对象自带length属性,数组名.length返回
  • this 和 一维数组

    2020-11-19 22:20:01
    一维数组 1、数组 java语言中的数组是一种引用数据类型 1.数组实际上是一个容器,可以容纳多个元素(同类型数据的集合)。 2.可以存储基本数据类型,也可以存储引用数据类型。 3.因为是引用类型,数组对象是堆...
  • Java一维数组入门

    多人点赞 2020-11-18 21:11:42
    一维数组入门 数组是一种用于存储数据的典型数据结构。 数组是有序的 数组存放的元素类型相同 一旦创建数组,数组的长度不可修改 数组的基本属性:数组的长度 通常使用数组名.length返回一个int类型的数表示...
  • 这里我们从一维数组开始,它也被称为线性数组。 动态数组简介 数组具有固定的容量,我们需要在初始化时指定数组的大小。有时它会非常不方便并可能造成浪费。 因此,大多数编程语言都提供内置的动态数组,它仍然是一...
  • C++的一维数组

    2020-10-31 20:35:32
    C++的一维数组 在超市中每件商品都有它们自己的价格,这些价格可以相等也可以不相等,这些一个个价格就是一个个单独的数据,但是有一天超市的老板要对一些价格进行调整或者是要看到超市里面的所有或一部分商品的价格...
  • Java 一维数组详解

    2021-02-23 12:01:23
    一维数组知识点: 一、数组的定义 1、Java 语言中的数组是一种引用数据类型。 不属于基本数据类型。 数组的父类是Object类 2、数组实际上是一个容器,可以同时容纳多个元素。( 数组是一个数据的集合。) 数组:字面...
  • Java笔记day03(数组之一维数组) 1.一维数组的声明与初始化 1、Java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。 2、数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据...
  • 一维数组,在计算机存储可以看成线性表或一个向量,它在计算机内存中存储的顺序是连续的,适合于随机查找,它有一个直接前驱与直接后继,二维数组可以看成是向量的推广,它有两个直接前驱和两个直接后继,三维数组...
  • 数组 array数组的内存结构数组数据结构的优缺点数组的声明定义与初始化以及存取一维数组怎么遍历对引用数组进行遍历数组的传参main方法的String数组一维数组的扩容 30. 数组 array java语言中的数组是一种引用数据...
  • 数组总结 及 静态初始化一维数组 /* Array: 1、java语言中的数组是一种引用数据类型,不属于基本数据类型,数组的父类是Object 2、数组实际上是一个容器,可以同时容纳多个元素(数组是一个数据的集合) 数组...
  • Java-一维数组总结

    2020-05-13 02:23:27
    数组实际上是个容器,可以同时容纳多个元素(数组个数据的集合) 数组: 字面意思是"组数据" 数组当中可以存储"基本数据类型"的数据,也可以存储"引用数据类型" 的数据 数组因为是引用类型,所以数组对象是...
  • 1.指针与一维数组(1)指针变量处理数组(2)数组的地址(3)通过一维数组名所代表的地址存取数组元素(4)通过指针运算符“ * ”存取数组元素(5)通过带下标的指针存取数组元素(6)等价规则2.移动指针及两指针...
  • 1.一维数组的取、存和遍历 1.1代码展示 1.2执行结果 1.3内存结构图展示 2.初始化一位数组 2.1代码展示 2.2执行结果 2.3内存结构图展示 3.方法的参数是数组(1) 3.1代码展示 3.2执行结果 4.方法的参数是数组(2) ...
  • 2、数组实际上是个容器,可以同时容纳多个元素(数组个数据的集合) 3、字面意思:数组意味着组数据 4、数组当中可以存储“基本数据类型”的数据,也可以存储“引用数据类型” 的数据 5、数组因为...
  • 离散数学-二维数组元素寻址

    千次阅读 2019-10-05 21:03:10
    数组元素的地址计算公式 (1) 按行优先顺序存储的二维数组Amn地址计算公式 LOC(aij)=LOC(a11)+[(i-1)×n+j-1]×d ...即顺序存储的数组是随机存取结构。 (2) 按列优先顺序存储的二维数组Amn地址计算公式 LOC(ai...
  •         一维数组 Array 1.java语言中的数组是一种引用数据类型,不属于基本数据类型。数组的父类是Object。 2.数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合。) 3.数组当中可以...
  • 多维数组的下标存取

    2017-03-18 10:02:00
    首先,多维数组的下标应该是个长度和数组数相同的元组,如果下标元组的长度比数组数大,就会出错,如果小,就会在下标元组的后面补“:”,使得他的长度与数组数相同,如果下标对象不是元组的画,则...
  • 维数组,容器 泛型

    2019-12-04 22:26:03
    维数组:可以简单理解为数组中存放数组 声明格式: 数据类型[ ] [ ] 数组名; 初始化分为两种:动态初始化与静态初始化 动态初始化: ​ 数据类型[ ] [ ] 数组名=new 数据类型[ 位数组的长度] [二维数组的长度 ] ...
  • Net二维数组的使用

    千次阅读 2017-02-28 09:44:11
    简要说明了二维数组的内存结构、定义及调用方法。
  • 自学JAVA-数组、二维数组、数组练习

    千次阅读 2021-06-15 16:33:30
    数组 1.为什么需要数组 定义26个char类型变量,... 可以一次性定义很多变量,并把这些变量从0开始编号(下标/索引),方便存取, 举例:房间 3.数组的语法 动态初始化 元素类型[] 数组名 = new 元素类型[数组长度];
  • 概念 数组是一种基本的数据结构,用于按顺序存储元素的集合。但是元素可以随机存取,因为数组中的每个元素都可以通过数组索引来识别。数组具有固定的容量,我们需要在初始化时指定数组的大小。...一维数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,206
精华内容 3,682
关键字:

一维数组可以随机存取