第五章数组

社牛专吃香菜

已于 2023-03-18 20:04:18 修改

阅读量157

点赞数

文章标签：数据结构算法 c语言 Powered by 金山文档

于 2023-03-14 15:45:01 首次发布

本文链接：https://blog.csdn.net/ywj18870318138/article/details/129526568

版权

变量只能存一个值

数组可以存储多个变量

一维数组

数组的声明有两种方法

1，数组元素的类型[] 数组名

2，数组元素的类型数组名[]

分配内存

数组名=new 数组元素的类型[数组长度]

分配内存的同时设置初始值

数组名=new 数组元素的类型[]{值1，值2，......值n}

数组元素赋值

数组名[索引] = 值；

例题5.1

package zuoye1;

public class 例题a {

    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,31,30,31,30,31};
        for(int i=0;i<12;i++) {
            System.out.println((i+1)+"月有"+day[i]+"天");
        }
    }

}

运行结果

二维数组

二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组

二维数组的声明

数组元素的类型数组名字[][];

数组元素的类型[][] 数组名;

二维数组分配内存

数组名 = new 数组元素的类型[行数][列数];

二维数组分配内存同时设置初始值

数组名 = new 数组元素的类型[][]{{值1，值2，...},{值1，值2，...},...,{值1，值2，...}};

二维数组元素赋值

数组名[] = {值1，值2，...};

数组名[行号][列号] = 值；

例题5.2

package zuoye1;

public class 例题b {

    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循环实现，二维数组需要使用双重for循环，通过数组length属性可获得数组的长度。

例题5.3

呈梯形输出二维数组中的元素

代码

package 第五章数组;
 
public class 例题c {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int b[][] = new int[][] {{1},{2,3},{4,5,6}};
//定义数组b并初始化
        for(int k = 0; k < b.length;k++) {
//定义int型变量k赋值0，判断k是否小于b的长度
            for(int j = 0;j<b[k].length;j++) {
//定义int型变量j赋值0，判断j是否小于数组b[k]的长度
                System.out.print(b[k][j]);
//输出数组b[k][j]
            }
            System.out.println();
//输出换行        
}
    }
 
}

输出结果

例题5.4

使用foreach语句遍历二维数组

代码

package 第五章数组;
 
public class 例题d {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr2[][] = {{4,3},{1,2}};
//定义int型数组arr2并初始化
        System.out.println("数组中的元素是：");
//输出字符串        
        int i = 0;
//定义int型变量i赋值0
        for(int x[]:arr2) {
//定义int型变量存放数组arr2并循环
            i++;
//i自增
            int j = 0;
//定义int型变量j赋值0
            for(int e:x) {
//定义int型变量存放循环后x的值并循环
                j++;
//j自增
                if(i == arr2.length && j == x.length) {
//如果i等于arr2的长度且j等于x的长度
                    System.out.print(e);
//输出e
                }
                else
//否则
                    System.out.print(e+"、");
//输出“、”
            }
        }
    }
 
}

运行结果

填充替换数组元素

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

fill（）方法有两种参数类型

替换数组部分元素：前改后不改

Arrays.fill(数组名，前索引，后索引，值)；

1，fill（int[] a,int value)

该代码可以将int分配给int型数组的每个元素。

代码中 a ;需要替换元素的数组

value ；存储数组中所有所有元素的值

2，fill（int[]a,int fromlndex,int tolndex,int value)

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

代码中

a；要进行填充的的数组

fromlndex；要使用指定值填充的第一个元素的索引（包括）。

tolndex；要分配给数组指定范围中的每个元素的值。

例题5.5

代码

package 第五章数组;
import java.util.Arrays;
public class 例题e {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr = new int[5];
//定义int型数组arr设置长度为5
        Arrays.fill(arr, 8);
//使用8对数组进行填充
        for(int i = 0;i < arr.length;i++) {
//定义int型变量i赋值0，判断i是否小于arr的长度，i自增
            System.out.println("第"+i +"个元素是："+arr[i]);
//输出数组第i个元素
        }
    }
 
}

例题5.6

package 第五章数组;
import java.util.Arrays;
public class 例题f {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr = new int[]{45,12,2,10};
//定义数组并初始化
        Arrays.fill(arr, 1,2,8);
//使用fill方法对数组进行替换值
        for(int i = 0;i < arr.length;i++) {
//定义int型变量i赋值0，判断i否则小于数组长度，i自增
            System.out.println(arr[i]);
//输出arr第i个值
        }
    }
}

数组排序

语法；Arrays.sort(object)

在项目类中创建taxis类，在主方法中创建一组数组，将数组排序后输出

例题5.7

代码

package 第五章数组;
 
import java.util.Arrays;
 
public class 例题g {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr = new int [] {23,42,12,8};
//定义数组并初始化
        Arrays.sort(arr);
//使用sort方法对数组进行从大到小排序
        for(int i = 0;i < arr.length;i++) {
//定义int型变量i赋值0，判断i是否小于数组长度，i自增
            System.out.println(arr[i]);
//输出arr第i个值
        }
    }
 
}

复制数组

复制数组部分元素：前在后不在

新数组名=Aeeays.copyof(旧数组名，前索引，后索引)；

例题5.8

代码

package 第五章数组;
import java.util.Arrays;
创建主方法
public class 例题h {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr = new int [] {23,42,12};
//定义数组arr并初始化
        int newarr[] = Arrays.copyOf(arr, 5);
//使用copyof方法将数组复制到newarr里
        for(int i = 0;i < newarr.length;i++) {
//定义int型变量i并赋值0，判断i是否小于newarr长度，i自增
            System.out.println(newarr[i]);
//输出数组第i个值
        }
    }
 
}

例题5.9

package 第五章数组;
import java.util.Arrays;
public class 例题i {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr = new int [] {23,42,12,84,10};
//定义数组arr并初始化
        int newarr[] = Arrays.copyOfRange(arr, 0,3);
//使用copyofRange方法复制指定值
        for(int i = 0;i < newarr.length;i++) {
//遍历数组
            System.out.println(newarr[i]);
//输出数组
        }
    }
 
}

查询数据

查询数组：先排序后查询

索引=Aeeays.copyof(旧数组名，值)；

例题5.10

package 第五章数组;
import java.util.Arrays;
//导入Arrays
public class 例题j {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []ia = new int [] {1,8,9,4,5};
//定义数组ia并初始化
        Arrays.sort(ia);
//使用sort方法进行排序
        int index = Arrays.binarySearch(ia, 4);
//使用binarySearch方法查找数组值4索引的位置
        System.out.println("4索引位置的值是："+index);
//输出索引的位置
    }
 
}

例题5.11

package 第五章数组;
import java.util.Arrays;
//插入Arrays类
public class 例题k {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String [] str = new String[] {"ab","cd","ef","yz"};
//定义数组并初始化
        Arrays.sort(str);
//应用sort方法进行排序
        int index = Arrays.binarySearch(str,0,2,"cd");
//将查询到的元素索引存储到index上
        System.out.println("cd的索引位置是："+index);
//输出查到的索引
    }
 
}

查询数组：先排序后查询

索引=Aeeays.copyof(旧数组名，值)；

数组元素排序

Arrays.sort（数组名）；

查询数组元素：先排序再查询

索引=Aeeays.copyof(旧数组名，元素)；

查询数组元素：先排序再查询，前含后不含

索引=Aeeays.copyof(旧数组名，前索引，后索引，元素)；

数组排序算法

冒泡排序：排序数组元素的过程总是将较小的数往前放，较大的数往后放

冒泡算法：由双层循环实现，其中外层循环由于控制排序轮数，一般为要排序数组长度减1次，因为最后一次循环只剩下一个数组元素。内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

例题5.12

package 第五章数组;
 
public class 例题r {
 
    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]赋值给temp
                    array[j] = array[j+1];
//把array[j+1]的值赋值给array[j]
                    array[j+1] = temp;
//把temp的值赋值给array[j+1]
                }
            }
        }
        showArray(array);
//输出排序
    }
    public void showArray(int[]array) {
        for(int i:array) {
//遍历数组
            System.out.print(">"+i);
//输出每个数组元素
        }
        System.out.println();
//输出换行
    }
 
}

直接选择排序

选择其中最大一个往后放一直循环

例题5.13

package 第五章数组;
 
public class 例题s {
 
    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-1 和 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();
//输出换行
    }
 
}

反转排序

把所有数值的顺序反转

例题5.14

package 第五章数组;
 
public class 例题y {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] array = {10,20,30,40,50,60};
//定义数组并初始化
        ReverseSort sorte = new ReverseSort();
//创建对象
        sorte.sort(array);
调用排序对象方法，将数组反转
    }
 
    private void sort(int[] array) {
        // TODO Auto-generated method stub
        System.out.println("数组原有内容：");
//输出字符串
        showArray(array);
//输出排序前元素
        int temp;
        int len = array.length;
        for(int i = 0;i < len/2;i++) {
            temp = array[i];
//调换值
            array[i] = array[len - 1 - i];
            array[len - 1 - i] = temp;
        }
        System.out.println("数组反转后内容：");
        showArray(array);
//输出反转后内容
    }
 
    private void showArray(int[] array) {
        // TODO Auto-generated method stub
        for(int i :array) {
//遍历数组
            System.out.print("\t"+i);
//输出结果
        }
        System.out.println();
//输出换行
    }
 
}