Java pop数组 java数组程序

本文记录Java数组的几个基本应用。

数组的初始化和遍历

数组初始化和遍历都有三种方式，参考如下代码。

1 import java.util.Arrays;
 2 public class ArrayDemo{
 3     public static void main(String[] args){
 4         //定义数组的三种方式
 5         //方法1 动态初始化
 6         int[] arr1=new int[3];
 7         arr1[0]=1;
 8         //方法2 静态初始化
 9         int[] arr2=new int[]{1,2,3};
10         //方法3 静态初始化省略写法
11         int [] arr3={1,2,3};
12         //遍历数组的三种方式
13         //方法1 普通for循环，通过下标获取，并且可以改变数组的值
14         System.out.println("-----------普通for循环-----------");
15         for(int i=0;i<arr1.length;i++){
16             arr1[i]*=2;
17         }
18         for(int i=0;i<arr1.length;i++){
19             System.out.println(arr1[i]);
20         }
21         //方法2 增强型for循环，只能遍历数组，不能改变数组的值
22         System.out.println("-----------增强型for循环-----------");
23         for(int number:arr2){
24             number*=2;
25         }
26         for(int number:arr2){
27             System.out.println(number);
28         }        
29         //方法3 使用Arrays.toString()方法返回
30         System.out.println("-----------使用Arrays.toString()方法返回-----------");
31         String str=Arrays.toString(arr3);
32         System.out.println(str);        
33     }
34 }

运行结果，注意增强型for循环只能进行遍历，不能对数组内容进行修改，另外静态初始化省略的写法不能分两步写，这个需要注意下。

求数组中最值

求数组中最值一般有两种思路，一种是比较数值直接得到最值，另外一种是比较后得到索引，本次使用后者。

1 public class ArrayMax{
 2     public static void main(String[] args){
 3         //获取一个数组中的最大值，采用记录下标的方式
 4         int[] arr=new int[]{12,34,1,7,5,44,98};
 5         int index=0;
 6         for(int i=1;i<arr.length;i++){
 7                 if(arr[i]>arr[index]){
 8                     index=i;
 9                 }
10         }    
11         //输出最大值
12         System.out.println(arr[index]);
13     }
14 }

运行结果

冒泡排序及时间&空间复杂度

数组的排序，Java提供了现成API可以处理，如Arrays.sort()方法（底层使用了快速排序+归并排序）可以对数组进行升序排列，此外还可以使用常用的排序方式，本文再次写冒泡和选择排序

（1）冒泡排序实现

1 import java.util.Arrays;
 2 public class BubbleSort{
 3     public static void main(String[] args){
 4         //冒泡排序练习
 5         /**
 6         数组相邻元素两两比较，得到最大值或最小值
 7         比如给一个长度为6的数组，将有如下比较逻辑：
 8         第1次比较，比较5次
 9         第2次比较，比较4次
10         ...
11         第5次比较，比较1次
12         得到比较轮序号+比较次数=数组长度
13         比较轮次：1~数组长度-1              
14         第i轮比较次数：数组长度-i
15         比较轮次使用外层for循环来控制，比较次数用内层for循环
16         */
17         int[] arr=new int[]{1,5,7,9,22,66,32,16,55,123,456};
18         //降序
19         for(int i=1;i<arr.length;i++){
20             for(int j=0;j<arr.length-i;j++){
21                 if(arr[j]<arr[j+1]){
22                     int temp=arr[j];
23                     arr[j]=arr[j+1];
24                     arr[j+1]=temp;
25                 }
26             }
27             System.out.println("排序后的数组为"+Arrays.toString(arr));
28         }    
29         /**
30         时间复杂度：O(n^2) 
31         比较次数即一个等差数列，去掉常数部分
32         空间复杂度：o(1)
33         由于创建了3个变量，因此表示为3*n^0，去掉常数3，空间复杂度为o(1)
34         */
35     }
36 }

排序过程及结果。

（2）选择排序实现

1 import java.util.Arrays;
 2 public class SelectSort{
 3     public static void main(String[] args){
 4         //选择排序练习
 5         /**
 6         比较数组当前位置元素和后面所有元素，如果后面存在比当前元素大或小的，交换数值，或者使用记录下标的方式
 7         最后交换下标的数组，这里暂时采用前种方式
 8         比如给一个长度为6的数组，将有如下比较逻辑：
 9         第1次比较，比较5次
10         第2次比较，比较4次
11         ...
12         第5次比较，比较1次
13         得到比较轮序号+比较次数=数组长度
14         比较轮次：1~数组长度-1              
15         第i轮比较次数：数组长度-i
16         比较轮次使用外层for循环来控制，比较次数用内层for循环
17         */
18         int[] arr=new int[]{1,5,7,9,22,66,32,16,55,123,456};
19         //降序
20         for(int i=0;i<arr.length-1;i++){
21             for(int j=i+1;j<arr.length;j++){
22                 if(arr[i]<arr[j]){
23                     //使用按位异或交换
24                     arr[i]=arr[i]^arr[j];
25                     arr[j]=arr[i]^arr[j];//arr[j]=arr[i]^arr[j]^arr[j]=arr[i];
26                     arr[i]=arr[i]^arr[j];//arr[i]=arr[i]^arr[j]^arr[i]=arr[j];
27                 }
28             }
29             System.out.println("排序后的数组为"+Arrays.toString(arr));
30         }
31         /**
32         时间复杂度：O(n^2) 
33         比较次数即一个等差数列，去掉常数部分
34         空间复杂度：o(1)
35         由于创建了3个变量，因此表示为3*n^0，去掉常数3，空间复杂度为o(1)
36         */
37     }
38 }

排序过程及结果。

数组的二分查找

当数组是有序的情况，可以使用二分查找来查找某个数是否存在，其时间复杂度为O(logn)，相比来说可能比冒泡和选择排序性能更加好。

1 import java.util.Scanner;
 2 import java.util.Arrays;
 3 public class BinarySearch{
 4     public static void main(String[] args){
 5         //使用二分查找寻找一个数在数组中的位置
 6         /**
 7         如果数组是有序数组，先比较这个数和数组中中间位置（(下标左边界+下标右边界)/2）数值的大小
 8         1 如果恰好找到了则返回数对应下标
 9         2 如果比中间值大，更新数组左边界
10         3 如果比中间值小，更新数组右边界
11         循环上面3个步骤，继续比较，循环的条件是 下标左边界不能大于下标右边界    
12         */
13         System.out.println("请输入要查找的数");
14         Scanner scan=new Scanner(System.in);
15         int number=scan.nextInt();
16         
17         int[] arr=new int[]{1,5,7,9,22,66,32,16,55,123,456,88};
18         //变成有序数组
19         Arrays.sort(arr);
20         //重新打印
21         System.out.println(Arrays.toString(arr));
22         int minIndex=0;
23         int maxIndex=arr.length-1;
24         int mid=(minIndex+maxIndex)/2;
25         while(minIndex<=maxIndex){
26             System.out.println("比较");
27             if(arr[mid]==number){
28                 System.out.println("数组的下标为："+mid);
29                 break;
30             }
31             if(arr[mid]<number){
32                 minIndex=mid+1;//mid对应的数都不相等，mid不需要比较了，继续往右边移动一位
33             }
34             if(arr[mid]>number){
35                 maxIndex=mid-1;//mid对应的数都不相等，mid不需要比较了，继续往左边移动一位
36             }
37             mid=(minIndex+maxIndex)/2;
38         }
39         /**
40         时间复杂度 O(logn)
41         空间复杂度 o(1)
42         */
43     }
44 }

测试结果

总结 

以上为数组的基本知识，后续可供参考。