数组中涉及的常见算法

数组中涉及的常见算法：

• 数组元素的赋值
• 求数值型数组中元素的最大值，最小值，平均数，总和等
• 数组的复制，反转，查找（线性查找，二分法查找）
• 数组的排序

练习题总结：

第一类问题：创建一个长度为6的int型数组，要求取值1-30，随机赋值，同时要求元素的值各不相同

public class ArrayExer {
    public static void main(String[] args) {
        int[] array=new int[6];
        for(int i=0;i<array.length;i++) {
            array[i]=(int) (Math.random() * 30)+1;//因为random是左闭右开式，所以得加一
            for(int j=0;j<i;j++) {
                if(array[i]==array[j]) {
                    i--;
                    break;
                }
            }
        }
        for(int i=0;i<array.length;i++) {
            System.out.println(array[i]);
        }
    }

}

理解：array[j]代表的是已生成的array[i];一旦有相等的值，就i--重新生成新的值；

第二类问题：创建一个int型的一维数组，包含10个元素，随机赋值，然后求取所有元素的最大值，最小值，平均数，总和等；要求：所有随机数都是两位数

public class ArrayExer2 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int Max = 0;
        int Avg = 0;
        int Sum = 0;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 99) + 1;
            System.out.println("第" + i + "个数是：" + arr[i]);
            // 求总和
            Sum += arr[i];
            // 求平均值
            Avg = Sum / 10;
            // 求最大值
            if (Max < arr[i]) {
                Max = arr[i];
            }
        }
        // 求最小值
        int Min = arr[1];
        for (int i = 0; i < arr.length; i++) {
            if (Min > arr[i]) {
                Min = arr[i];
            }
        }
        System.out.println("这十个数中的最大值是：" + Max);
        System.out.println("这十个数中的最小值是：" + Min);
        System.out.println("这十个数平均数是：" + Avg);
        System.out.println("这十个数总和是：" + Sum);
    }
}

 运行结果：

 第三类问题之其一：数组的复制。

• 创建一个名为ArraExer3的类，在main（）方法中声明array1和array2两个变量，他们是int[]类型的数组，
• 使用{}，把array1初始化为八个素数：2，3，5，7，11,13，17，19；

• 显示array1的内容
• 赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0；array[2]=2；）打印出array1；

public class ArrayExer3 {
public static void main(String[] args) {
    int[] array1=new int[] {2,3,5,7,11,13,17,19};
    //遍历array1[]
    for(int i=0;i<array1.length;i++) {
        System.out.print(array1[i]+" ");
    }
    int[] array2=array1;//这个操作不能成为数组的复制
    //修改array2中的偶索引元素
    for(int i=0;i<array1.length;i++) {
        if(i%2==0) {
            array2[i]=i;
        }
        System.out.println();
        System.out.print("修改后的array1为："+array1[i]+" ");
    }
    System.out.println();
    System.out.println(array1);
    System.out.print(array2);
}
}

运行结果:

此时，内存存储情况如下图所示:

理解：通过此例，说明第八行的操作并不是复制，而是类似于Windows的创建快捷键。

array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。内存中只有出现new才在堆中开辟新的内存空间。

 改正之后：

• 创建一个名为ArraExer3的类，在main（）方法中声明array1和array2两个变量，他们是int[]类型的数
• 使用{}，把array1初始化为八个素数：2，3，5，7，11,13，17，19；
• 显示array1的内容
• 实现array2对array1的复制，修改array2中的偶索引元素，使其等于索引值（如array[0]=0；array[2]=2；）打印出array1；

public class ArrayExer3 {
public static void main(String[] args) {
    int[] array1=new int[] {2,3,5,7,11,13,17,19};
    //遍历array1[]
    for(int i=0;i<array1.length;i++) {
        System.out.print(array1[i]+" ");
    }
    //数组的复制
 9     int[] array2=new int[8];
10     for(int i=0;i<array2.length;i++) {
11         array2[i]=array1[i];
12     }
    //修改array2中的偶索引元素
    for(int i=0;i<array1.length;i++) {
        if(i%2==0) {
            array2[i]=i;
        }
        System.out.println();
        System.out.print("修改后的array2为："+array2[i]+"         ");
        System.out.print("修改后的array1为："+array1[i]+" ");
    }
    System.out.println();
    System.out.println(array1);
    System.out.print(array2);
}
}

运行结果:

此时，内存存储情况变为  如下图所示:

 第三类问题之其二：数组的反转。

public class ArrayExer5 {
    public static void main(String[] args) {
        String[] arr = new String[] { "WW", "ZZ", "YY", "MM", "DD", "SS", "XX" };
        // 数组的反转
        for (int i = 0; i < arr.length / 2; i++) {
            String temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");

        }
    }
}

运行结果：

 第三类问题之其三：数组的查找———线性查找

   

public class ArrayExer5 {
    public static void main(String[] args) {
        String[] arr = new String[] { "WW", "ZZ", "YY", "MM", "DD", "SS", "XX" };
        // 数组的查找
        String dest = "YY";

        boolean isflag = true;
        for (int i = 0; i < arr.length; i++) {
            if (dest == arr[i]) {
                System.out.println("找到了指定的元素：" + "位置在" + i);
                isflag = false;
                break;
            }

        }
        if (isflag) {
            System.out.println("很遗憾，没有找到您要的数据!");
        }
    }
}

运行结果：

 第三类问题之其三：数组的查找———二分法查找

前提：所要查找的数组必須有序；

public class ArrayExer6 {
public static void main(String[] args) {
    int[] arr=new int[] {-23,34,61,94,134,165};
    int dest=34;
    //初始的首索引
    int head=0;
    //初始的末索引
    int end=arr.length-1;
    boolean isFlag = true;
    while(head<=end) {
        int middle=(head+end)/2;
        if(dest==arr[middle]) {
            System.out.println("找到了指定的元素：" + "位置在" + middle);
            isFlag=false;
            break;
            }else if(dest<arr[middle]) {
                end=middle-1;
            }else {
                head=middle+1;
            }
    }
    if(isFlag) {
        System.out.println("很遗憾，没有找到您要的数据!");
        
    }
}
}

 第四类问题：数组的排序之冒泡排序

public class Bubblesort {
public static void main(String[] args) {
    int[] arr=new int[] {-12,45,62,72,19,-12,95,39};
    //冒泡排序 升序排列
    for(int i=0;i<arr.length;i++) {
        for(int j=0;j<arr.length-1-i;j++) {
            if(arr[j]>arr[j+1]) {//改成小于就是降序排列
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    for(int i=0;i<arr.length;i++) {
        System.out.print(arr[i]+"   ");
    }
}
}

运行结果：

 

八种排序的比较：