05数组、排序、查找
目录
数组
数组的介绍:
数组可以存放多个同一类型的数据.数组也是一种数据类型,是引用类型.
即:数(数据)组(一组)就是一组数据.
数组的定义:
第一种:
数组类型 数组名[] = new 数据类型[大小]
int a[] = new int[5];//创建了一个数组,名字a,存放5个int
说明:这是定义数组的一种方法.
第二种:
先声明数组
语法:数据类型 数组名[];也可以数据类型[] 数组名;如:int a[]; int[] a;
创建数组
语法:数组名 = new 数据类型[大小];
a=new int[10];
第三种:
初始化数组
语法:数据类型 数据吗[] = {元素值,元素值...}
int a[] = {2,3,4,6,7,8},如果知道数组有多少元素,具体值
上面的用法相当于:int[] a = new int[6];
数组的引用(使用)
数组名[下标/索引] 如:你要是有a数组的第三个数a[2]
数组的使用细节和注意事项:
1.数组是多个相同类型数据的组合,实现对这些数据的统一管理
2.数组中的元素可以是任何数据类型,包括基本类型和引用类型,但是不能混用.
3.数组创建后,如果没有复制,有默认值,int 0;short 0;byte 0;long 0;float 0.0;double 0.0;char \u0000; boolean false; String null;
4.使用数组的步骤:1声明数组并开辟空间 2给数组各个元素赋值 3使用数组
5.数组的下标是从0开始的
6.数组下标必须在指定范围内使用,否则报:下标越界异常.
如:int[] arr = new int[5];则有效下标为0~4
7.数组属于引用类型,数组型数据是对象(object)
案例
循环输入五个成绩,保存到double数组,并输出
Scanner scanner = new Scanner(System.in);
//第一种动态分配方式
double[] d = new double[5];
//第二种分配方式
//double d[];
//d = new double[5];
for(int i=0;i<d.length;i++ ){
System.out.println("请输入第"+(i+1)+"个成绩");
d[i] = scanner.nextDouble();
}
for(int i=0;i<d.length;i++){
System.out.print("第"+(i+1)+"个成绩:"+d[i]+"\n");
}
创建一个char类型的26个元素数组,分别放置'A'~'Z'.使用for循环访问索引元素并打印出来
定义一个数组char[] c = new char[26];
因为A+1=B类推所以可以使用for来赋值
char[] c = new char[26];
for(int i=0;i<c.length;i++){
c[i] = (char)('A' + i);
System.out.print(c[i] + " ");
}
求出一个数组int[]最大的值{4,-1,9,10,23},并得到对应的下标.
//定义一个数组int[] array = {4,-1,9,10,23};
//定义最大值max = arr[0];max1=0为下标
//从下标1开始遍历arr,如果max<当前元素,说明max不是真正的最大值,我们就max=当前元素;maxIndex=当前元素下标
int[] array = {4,-1,23,10,9};
int max1=0;
for(int i=1;i<array.length;i++){
if(array[max1]>array[i]){
}else{
max1 = i;
}
}
System.out.println("当前数组最大值为:"+array[max1]+"下标值为"+max1);
求出一个数组的和还有平均值
int[] array = {4,-1,23,10,9};
int sum = 0;//总和
double average = 0.0;//平均值
for(int i=0;i<array.length;i++){
sum += array[i];//求和
}
average = sum/array.length;//求平均值
System.out.println("当前数组的和为:"+sum+"当前数组的平均值为:"+average);
数组赋值机制：
1基本数据类型赋值，这个值就是具体的数据，而且相互不影响int n1=2；int n2=4；
2数组在默认情况下是引用传递，赋的值是地址。
案例：
把数组的元素内容反转：
arr{11,22,33,44,66,77}→{77,66,44,33,22,11}
int[] arr = {11,22,33,44,66,77};
/*
把arr[0]和arr[5]进行交换
以供交换3次 = arr.length/2
每次交换时,对应的下标是arr[i]和arr[arr.length-1-i]
int temp = 0;
int len = arr.length;//计算数组的长度
for(int i=0;i<len/2;i++){
temp = arr[len-1-i];//保存
arr[len-1-i] = arr[i];
arr[i] = temp;
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
实现动态的给数组添加元素效果，实现对数组扩容
原始数组使用静态分配int[] arr={1,2,3}
增加的元素4,直接放在数组的最后arr={1,2,3,4}
用户可以通过如下方法来决定是否继续添加,添加成功,是否继续?Y/N
/*
实现动态的给数组添加元素效果，实现对数组扩容
1原始数组使用静态分配int[] arr={1,2,3}
2增加的元素4,直接放在数组的最后arr={1,2,3,4}
3用户可以通过如下方法来决定是否继续添加,添加成功,是否继续?Y/N
*/
/*
1定义初始数组 int[] arr={1,2,3}
2定义一个新的数组int [] arrNew = new int{arr.length+1};
3遍历arr数组,依次将arr的元素拷贝到arrNew数组
4将4赋给arrNew[arrNew.length-1]=4;把4赋给arrNew最后一个元素
5让arr指向arrNew;arr=arrNew;那么原来arr数组就被销毁
6创建一个Scanner可以接受用户输入
7因为用户不知道什么时候退出,可以使用do-while+break来控制
*/
int[] arr = {1,2,3};
Scanner scanner = new Scanner(System.in);
do{
int[] arrNew = new int[arr.length+1];
//遍历arr数组,依次将arr的元素拷贝到arrNew数组
for(int i=0;i<arr.length;i++){
arrNew[i] = arr[i];
}
System.out.println("请输入你要添加的元素");
int addNum = scanner.nextInt();
//把addNum赋给arrNew最后一个元素
arrNew[arrNew.length-1] = addNum;
//让arr指向arrNew;
arr=arrNew;
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
//问用户是否继续添加
System.out.println("是否继续添加y/n");
char key = scanner.next().charAt(0);
if(key == 'n'){
break;
}
}while(true);
有一个数组{1,2,3,4,5}可以将数组进行缩减,提示用书是否继续缩减,每次缩减最后那个元素,当只剩下最后一个元素,提示,不能再缩减了.
排序
排序介绍:
1内部排序:
指将需要处理的所有数据都加载到内部存储器中进行排序.包括(交换式排序法,选择式排序法和插入式排序法);
2外部排序法:
数据量过大,无法全部加载到内存中,需要借助外部存储进行排序.包括(合并排序法和直接合并排序法).
3冒泡排序特点:
假设我们一共有5个数组
一共进行了4轮排序,可以看成是外层循环
每1轮排序可以确定一个数的位置,比如第1轮排序确定最大数,第2轮排序,确定第2大的数位置,以此类推
当进行比较时,如果前面的数大于后面的数,就交换
每轮比较在减少4→3→2→1
查找
查找介绍:
1顺序查找
2二分查找
案例:
有一个数列:白眉,金毛,紫衫,青翼猜数游戏:从键盘中任意输入一个名称,判断数列中是否包含此名称[顺序查找]要求:
如果找到了,就提示找到了,并给出下标值.
String[] name = {"白眉","金毛","紫衫","青翼"};
Scanner scanner = new Scanner(System.in);
System.out.println("请输入名字");
String fName = scanner.next();
int index = -1;
for(int i=0;i<name.length;i++){
//比较字符串equals
if(fName.equals(name[i]){
System.out.println("恭喜你找到了"+fName);
System.out.println("下标为:" + i);
}
}
if(index == -1){//没有找到
System.out.println("没有找到");
}
请对一个有序数组进行二分查找{1,8,10,89,1000},输入一个书看看该数组是否存在此数,并且求出下标,如果没有就提示"没有这个数".
多维数组
1二维数组的介绍:
从定义形式上看int[][]
可以这样理解,原来的一维数组的每个元素是一维数组,就构成二维数组
int[][] arr={{1,2,3},{4,5,6},{7,8,9}};
关于二维数组的关键概念
System.out.println("二维数组的元素个数="+arr.length);
1二维数组的每个元素是一维数组,所以如果需要得到每个一维数组的值还需要再 次遍历
2如果我们要访问第(i+1)个一维数组的第j+1个值arr[i][j];
举例:访问3,→它是第1个一维数组的第3个值arr[0][2];
System.out.println("第1个一维数组的第3个值"+arr[0][2]);
//输出二维图形
for(int i=0;i<arr.length;i++){//遍历二维数组的每个元素
//遍历二维数组的每个元素(数组)
//1.arr[i]表示二维数组的第i+1个元素比如arr[0]:二维数组的第一个元素
//2.arr[i].length得到对应的每个一维数组的长度
for(int j=0;j<arr[i].length;j++){
System.out.print("arr["+i+"]["+j+"]"+arr[i][j]+" ");
//输出了一维数组
}
System.out.println();
}
二维数组的使用:
语法:类型[][] 数组名 = new 类型[][]
如int a[][] = new int[1][2];
二维数组使用细节和注意事项:
1一维数组的声明方式有:
int[] x或者int x[]
2二维数组的声明方式有:
int[][] x或者int y[][] 或者int[] y[]
3二维数组实际上市由多个一维数组组成的,它的各个一维数组的长度可以相同,也可以不相同.
map[][] = {{1,2},{3,4,6}}
由map[0]是一个含有两个元素的一维数组,map[1]是一个含有是哪个元素的一维数组构成,我们也称为列数不等的二维数组.
使用方法二:动态初始化
先声明:类型 数组名[][];
在定义(开辟空间)数组名 = new 类型[][];
赋值(有默认值,比如int 类型的就是0);
使用方法三:动态初始化-列数不确定
动态创建下面二维数组,并输出:
j/i i=0 j=1 j=2
i=0 1
i=1 2 2
i=2 3 3 3
使用方法四:静态初始化
定义类型 数组名[][]={{},{},{}};
使用即可{固定方式访问}如:
int[][] arr = {{1,1,1},{2,2},{3}}
定义了一个二维数组arr
arr有三个元素(每个元素都是一维数组)
第一个一维数组有3个元素,第二个一维数组有2个元素,第三个一维数组有1个元素
//int arr[][] = {{2,3},{1,2,3},{-1}};遍历该二维数组,并得到和
int arr[][] = {{2,3},{1,2,3},{-1}};
int sum = 0;
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
sum += arr[i][j];
}
}
System.out.println("和:"+sum);
案例:
使用二维数组打印一个10行杨辉三角
1
11
121
1331
14641
1第一行有1个元素,第n行有n个元素
2每一行的第一个元素和最后一个元素都是1
3从第三行开始,对于非第一个元素和最后一个元素的元素值.4,2
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
作业：
1、下面数组定义正确的有//B,D
A.String arr[] = {'a','b'};
B.String[] arr = {"a","b"};
C.String[] arr = new String{"a","b"}
D.String arr[] = new String[]{"a","b"}
E.String[] arr = new String[2]{"a","b"}
2、写出结果//blue
String foo = "blue";
boolean[] bar = new boolean[2];//bar[0]默认false bar[1]false
if(bar[0]){
foo = "green";
}
System.out.println(foo);//答案blue。bar[0]是false所以foo="green"不执行
3、以下Java代码的输出结果为//1,3,5,7
int num = 1;
while(num<10){
System.out.println(num);//1,3,5,7
if(num>5){
break;
}
num += 2;
}
4、已知有个升序的数组，要求插入一个元素。该数组顺序依然是升序，如：
[10,12,43,90],添加23后，数组为[10,12,23,45,90]
//思路：扩容+定位
//我们先确定添加数应该插入到哪个索引
//然后扩容
//定义数组
int[] arr = {10,12,43,90};
int num = 23;
int index = -1;//index定位
//遍历arr数组，如果发现num<=arr[i],说明i就是要插入的位置
//使用index保留index=i；
//如果遍历完，没有发现num<=arr[i]，说明index = arr.length
//即添加在arr的最后
for(int i=0;i<arr.length;i++){
if(num<=arr[i]){
index = i;
break;//找到位置后，就退出
}
}
//判断index的值
if(index == -1){//说明还没有找到位置
index = arr.length;
}
//扩容
//先创建一个新的数组，大小arr.length+1
int[] arrNew = new int[arr.length+1];
//将arr的元素复制到arrNew，并且要跳过index位置
for(int i=0,j=0;i<arrNew.length;i++{
if(i != index ){//说明可以把arr的元素复制到arrNew
arrNew[i] = arr[j];
j++;
}else{//i这个位置就是要插入的数
arrNew[i] = num;
}
}
//让arr指向arrNew，原来的数组
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]+" ");
}
5.随机生成10个整数(1_100的范围)保存到数组，并倒序打印以及求平均值、求最大值和最大值的下标、并查找里面是否有8
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*100)+1;
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
System.out.println("倒序");
for(int i = arr.length-1;i>=0;i--){
System.out.print(arr[i]+" ");
}
//平均值、求最大值和最大值下标
//我们这里将需求一起完成
double sum = arr[0];
int max = arr[0];
int maxIndex = 0;
for(int i=1;i<arr.length;i++){
sum += arr[i];//累积和
if(max<arr[i]){//说明max不是最大值，就变化
max = arr[i];
maxIndex = i;
}
}
System.out.println("max="+max+"maxIndex="+maxIndex);
System.out.println("平均值="+(sum/arr.length));
//查找数组中是否有8→使用顺序查找
int findNum=8;
int index = -1;//如果找到，就把下标记录到index
for(int i=0;i<arr.length;i++){
if(findNum == arr[i]){
System.out.println("找到数"+findNum+"下标"+i);
index=1;
break;
}
}
if(index == -1){
System.out.println("没有找到数"+findNum);
}
6写出下面代码的结果//aa,zz,沈沈
char[] arr1={'a','z','c'};
char[] arr2=arr1;
arr1[2]='沈';
for(int i=0;i<arr2.length;i++){
System.out.println(arr1[i]+","+arr2[i])
}
浙公网安备 33010602011771号