第五章 数组

最新推荐文章于 2024-10-09 22:28:58 发布
最新推荐文章于 2024-10-09 22:28:58 发布
阅读量105 收藏
点赞数
文章标签： 数据结构 算法 numpy Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74339463/article/details/129526937
版权

一维数组

数组作为对象允许使用new关键词进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。

一维数组的创建有两种形式。

  • 先声明，再用new关键词进行内存分配

声明一维数组有下列两种方式：

  • 分配内存空间

使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0.


public class GetDay {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
        //for循环遍历数组
        for(int i=0;i<12;i++){//利用循环将信息输出。 如改成”i<13“数组下标越界，会出现报错
            System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
        }
    }

}

public class GetDay {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
        //for循环遍历数组
        for(int i=0;i<day.length;i++){//利用循环将信息输出。 加length避免下标越界
            System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
        }
    }

}

运行结果：

public class Foreach {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]= {5,13,96};//一维整型数组
        System.out.println("一维数组中的元素分别是：");
        //foreach循环遍历数组,避免下标越界
        //x的类型与arr元素的类型相同。for循环依次取出arr中的值并赋给x
        for(int temp:arr) {
            System.out.println(temp);//输出遍历出的元素值
            }
    }

}

运行结果：

二维数组

如果一组数组中的各个元素任然是一个数组，那么它就是一个二维数组，二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列

二维数组可以看作是特殊的一维数组，因此二维数组的创建同样有两种方式。

  • 先声明，再用new关键字进行内存分配

语法如下：

  • 内存的分配

初始化二维数组后，要明确数组的下标都是从0开始。


public class Matrix {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        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();//输出空格
    }

}
}

运行结果：

数组的基本操作

遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。

遍历二维数组需使用双层for循环，通过数组的length属性可获得数组长度。

在遍历数组时，使用foreach语句可能会更简单。


public class Tautog {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr2[][]= {{4,3},{1,2}};//定义二维数组
        System.out.println("数组中的元素是：");//提示信息
        int i=0;//外层循环计数器变量
        for(int x[]:arr2) {//外层循环变量为一维数组
            i++;//外层计数器递增
            int j=0;//内层循环计数器变量
            for(int e:x) {//循环遍历每一个数组元素
                j++;//内层计数器递增
                if(i==arr2.length&&j==x.length) {//判断变量是二维数组的最后一个元素
                    System.out.print(e);//输出二维数组的最后一个元素
                }else//如果不是二维数组的最后一个元素
                    System.out.print(e+"、");//输出信息
            }
        }
    }

}

运行结果：

替换数组

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型：

  1. fill(int[] a,int value)
import java.util.Arrays;//导入java.util.Arrays类

public class Swap {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[5];//创建int型数组
        Arrays.fill(arr,8);//使用同一个值对数组进行填充
        for(int i=0;i<arr.length;i++) {//遍历循环数组中的元素
            System.out.println("第"+i+"个元素是:"+arr[i]);//将数组中的元素依次输出
        }
    }

}

运行结果：

  1. fill(int[] a,int fromlndex,int tolndex,int calue)

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromlndex（包括）一直到索引tolndex（不包括）。如果fromlndex=tolndex，则填充范围为空。

import java.util.Arrays;//导入java.util.Arrays类

public class Displace {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {45,12,2,10};//定义并初始化int型数组arr
        Arrays.fill(arr,1,2,8);//使用fill()方法替换数组指定范围内的元素
        for(int i=0;i<arr.length;i++) {//循环遍历数组中的元素
        System.out.println("第"+i+"个元素是："+arr[i]);//将数组中的每个元素输出
    }

}
}

运行结果：

对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

import java.util.Arrays;//导入java.util.Arrays类

public class Taxis {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,8};//声明数组
        Arrays.sort(arr);//将数组进行排序
        for(int i=0;i<arr.length;i++) {//循环遍历排序后的数组
            System.out.println(arr[i]);//将排序后数组中的各个元素输出
        }
    }

}

运行结果：

复制数组

Arrays类的copyOf()方法与copyRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyRange()方法则将指定数组的指定长度复制到一个新数组中。

  1. copyOf()方法

该方法提供了多种重载形式，用于满足不同类型数组的复制。语法如下：

import java.util.Arrays;//导入java.util.Arrays类

public class Cope {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12};//定义数组
        int newarr[]=Arrays.copyOf(arr,5);//复制数组arr
        for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
            System.out.println(newarr[i]);//将新数组输出
        }
    }

}

运行结果：

2、copyRange()方法

该方法同样提供了多种重载形式。语法如下：

import java.util.Arrays;//导入java.util.Arrays类

public class Repeat {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,84,10};//定义数组
        int newarr[]=Arrays.copyOfRange(arr,0,3);//复制数组
        for (int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
            System.out.println(newarr[i]);//将新数组中的每个元素输出
        }
    }

}

运行结果：

查询数组

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

1、binarySearch(Object[] a,Objrct key)

语法如下：

import java.util.Arrays;//导入java.util.Arrays类

public class Reference {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int ia[]=new int[] {1,8,9,4,5};//定义int型数组ia
        Arrays.sort(ia);//将数组进行排序
        int index=Arrays.binarySearch(ia,4);//查找数组ia中元素4的索引位置
        System.out.println("4的索引位置是："+index);//将索引输出
    }

}

运行结果：

2、binarySearch(Object[] a,int fromlndex,int tolndex,Objrct key)

该方法在指定的范围内检索某一元素。语法如下：

import java.util.Arrays;//导入java.util.Arrays类

public class Rakel {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        String str[]=new String[] {"ab","cd","ef","yz"};//定义String型数组str
        Arrays.sort(str);//将数组进行排序
        int index=Arrays.binarySearch(str,0,2,"cd");//在指定范围内搜索元素“cd”的索引位置
        System.out.println("cd的索引位置是："+index);//将索引输出
    }

}

运行结果：

数组排序算法

冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

public class BubbleSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        BubbleSort sorter= new BubbleSort();//创建冒泡排序类的对象
        sorter.sort(array);//调用排序方法，对数组排序
    }
    public void sort(int[] array) {
        for (int i=1;i<array.length;i++) {
            //比较相邻两个元素，比较的元素往后冒泡
            for(int j=0;j<array.length-i;j++) {
                if(array[j]>array[j+1]) {
                    int temp=array[j];//把第一个元素值保存到临时变量中
                    array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
                    array[j+1]=temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
                }
            }
        }
        showArray(array);//输出冒泡排序后的数组元素
    }
    private void showArray(int[] array) {
        // TODO Auto-generated method stub
        for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
            
        }
        System.out.println();
    }

}

运行结果：

直接选择排序

直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法


public class SelectSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[]array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        SelectSort sorter=new SelectSort();//创建直接排序类的对象
        sorter.sort(array);//调用排序对象方法，对数组排序
    }

    private void sort(int[] array) {
        // TODO Auto-generated method stub
        int index;
        for(int i=1;i<array.length;i++) {
            index=0;
            for(int j=1;j<array.length-i;j++) {
                if(array[j]>array[index]) {
                    index=j;
                }
            }
            //交换在位置array.length-i和index(最大值)上的两个数
            int temp=array[array.length-i];//把第一个元素值保存到临时变量中
            array[array.length-i]=array[index];//把第二个元素值保存到第一个元素单元中
            array[index]=temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
        }
        showArray(array);//输出直接选择排序后的数组元素
    }

    private void showArray(int[] array) {
        // TODO Auto-generated method stub
        for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
        }
        System.out.println();
    }

}

运行结果：

反转排序

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

迟早会把头薅秃
关注
Arrays的用法
你好，严宝辉
06-08 1552
Arrays的用法 arrays是Sun公司就在JDK中提供了一个数组的工具类，此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。 package com.JAVABASIS5; import java.util.Arrays;; public class Practice { public static void main(S
信息学奥赛一本通-教程PPT课件（第五版）第5章 数组(C++版).ppt
03-03
信息学奥赛一本通-教程PPT课件（第五版）
第5章数组
kdkdksjs的博客
03-21 117
System.out.println((i + 1) + "月有" + day[i] + "天");System.out.println("第" + i + "个元素是： " + arr[i]);System.out.println("第" + i + "个元素是： " + arr[i]);System.out.println("cd的索引位置是： " + index);System.out.println("数组中的元素是：");声明： 数组元素的类型 数组名字[ ][ ];
【例 5.6】 使用Arrays.fill()方法替换数组中的元素
qq_43118674的博客
03-15 201
【例 5.6】 使用Arrays.fill()方法替换数组中的元素
数组的定义与元素访问
Judian6974的博客
08-02 2019
数组的定义与元素访问 定义有三种方式： （1）var a = [ ]; （2）var a = new Array( ); （3）var a = [0,0,0]; 访问元素：数组名+下标 a[0]  a[3] 需要注意下标从0开始。 所以在使用的时候需要注意越界问题，比如5个元素的数组，那么它的下标范围是[0，4]，不包括5，5已经越界了。 数组的本质：一组变量（数据）的集合，或者
Java：Arrays.fill() 方法
AuNPS的博客
05-02 9845
public static void fill(int[] a, int fromIndex, int toIndex, int val) Arrays类的fill() 方法是用来输入给定数组中元素值的。 1、两个参数 public static void fill(int[] a， int val)：给定一个数组，一个val值 含义为为数组a进行赋值，使得其所有元素值都为val。 2、四个参数 public static void fill(int[] a, int fromIndex, int toI
c语言入门经典第五章数组,第五章数组的概念
weixin_29214691的博客
05-20 569
5.1数组简介说明数组的概念的及其作用的最好方法，是通过一个例子，来说明使用数组后程序会变得非常简单5.1.1 不用数组的程序如何声明一个数组数据类型 数组名称[长度];C语言中的数组初始化是有三种形式的数据类型 数组名称[长度n] = {元素1,元素2…元素n};数据类型 数组名称[] = {元素1,元素2…元素n};数据类型 数组名称[长度n]; 数组名称[0] = 元素1; 数组名称[1] ...
Java第五章数组
好好活就是做有意义的事，做有意义的事就是好好活
03-17 358
本篇文章，主要讲述了数组概述，一维数组，二维数组，数组的基本操作，数组排序算法
数据结构练习（含答案）：第五章数组和广义表.doc
09-20
数据结构练习（含答案）：第五章数组和广义表 本资源摘要信息涵盖了数据结构中数组和广义表的相关知识点，包括数组的基本操作、数组的存储方式、稀疏矩阵的压缩存储方法、对称矩阵的存储方式等。 一、选择题 1. ...
数据结构第五章数组与广义表
12-09
本人上课时老师的课件，讲的还不错，所以建议大家看看
第五章 数组.docx
09-26
第五章 数组主要介绍了在程序设计中如何使用数组这一重要的数据结构。数组是将相同类型的多个变量有序组织在一起的集合，它可以是数值数组、字符数组、指针数组或结构数组等。C语言中的数组被视为构造数据类型，由...
数据结构课程中的第五章 数组和广义表PPT
03-26
南航数据结构课程中的第五章 数组和广义表PPT。
【数据结构强化】应用题打卡
Father_Of_Soft的博客
10-03 811
王道应用题打卡
《数据结构》学习系列——树（上）
Kenjuan的博客
10-01 921
一个树（或树形）就是一个有限非空的结点集合T，其中：有一个特别标出的被称为该树（或树形）之根root(T)的结点其余结点 （根除外）被分成m≥0个不相交的集合T1，T2，...，Tm，且T1，T2，...，Tm又都是树（或树形）。树（或树形）T1，T2，...，Tm被称作root(T)的子树（或子树形（非递归定义）定义：树是包含n（n≥1）个结点且满足如下条件的有限集合存在一个唯一的结点v0，它没有前驱结点，称为树的根（或根结点）任何非根结点都有且仅有前驱节点，称为该节点的父结点。
Java.数据结构.TreeSet
TJKFYY的博客
10-03 317
TreeSet是Java集合框架中的一部分，是基于TreeMap实现的。TreeSet保证了集合中的元素按照自然顺序或者通过提供的Comparator进行排序。：TreeSet会根据元素的自然顺序进行排序，确保集合中的元素总是处于有序状态，和TreeMap一样，我们同样可以通过重写Comparator方法来进行排序。：TreeSet中的元素是唯一的，不能重复。如果有两个元素相等，则后插入的元素不会出现在集合中。：TreeSet基于TreeMap实现，其时间复杂度为O(log n)。
Java：数据结构-初始结合框架 时间复杂度和空间复杂度 初识泛型
blamep的博客
10-07 913
Java 的集合框架（Java Collection Framework，JCF）是 Java 标准库中的一部分，用于存储和操作一组数据。它提供了一些常用的数据结构和接口，用来高效管理和操作数据。Java 的集合框架位于java.util包中。
【C++算法】8.双指针_四数之和
hlyd520的博客
10-04 602
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
[算法] 数组
最新发布
Letmooning的博客
10-09 312
- 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。
数据结构：第5章数组与广义表详解
第五章深入剖析了数组和广义表这两种基础的数据结构，它们在算法设计和实现中起着关键作用。无论是数组的顺序存储和优化，还是广义表的非线性特性，都是理解高级数据结构和算法的关键知识点。掌握这些概念对于从事IT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值