java 基本语法（十一） 数组（四）数组的常见算法

1.数组的创建与元素赋值：

杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。

杨辉三角

public class YHSJ {
    public static void main(String[] args) {
        //定义了一个长度为10，高度为10的二维数组，数组中的值都为0；
        int[][] arr=new int[10][10];
        for(int i=0;i<arr.length; i++) {
            //由于只是给杨辉三角内的位置赋值，所以是j<=i
            for(int j=0;j<=i;j++) {
                //根据规律，使用if else 赋值
                if(j==0||j==i) {
                    arr[i][j]=1;
                }else {
                    arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                }
                /*由于只是输出杨辉三角范围内的值，所以在内层循环就输出，这种方法不能全部赋值完之后再输出
                    "\t"的原因是10和小于10的数组的宽度不同，所以使用\t制表符能使数与数之间距离相等
                */
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }

}

回形数格式方阵

class RectangleTest1 {

    public static void main(String[] args) {
        int n = 7;
        int[][] arr = new int[n][n];

        int count = 0; // 要显示的数据
        int maxX = n - 1; // x轴的最大下标
        int maxY = n - 1; // Y轴的最大下标
        int minX = 0; // x轴的最小下标
        int minY = 0; // Y轴的最小下标
        while (minX <= maxX) {
            for (int x = minX; x <= maxX; x++) {
                arr[minY][x] = ++count;
            }
            minY++;
            for (int y = minY; y <= maxY; y++) {
                arr[y][maxX] = ++count;
            }
            maxX--;
            for (int x = maxX; x >= minX; x--) {
                arr[maxY][x] = ++count;
            }
            maxY--;
            for (int y = maxY; y >= minY; y--) {
                arr[y][minX] = ++count;
            }
            minX++;
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                String space = (arr[i][j] + "").length() == 1 ? "0" : "";
                System.out.print(space + arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

6个数，1-30之间随机生成且不重复。

class ArrayExer {
    public static void main(String[] args) {
        int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
            arr[i] = (int) (Math.random() * 30) + 1;

                for (int j = 0; j < i; j++) {
                    if (arr[i] == arr[j]) {
                        i--;
                        break;
                    }
                }
            }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

2.针对于数值型的数组：

最大值、最小值、总和、平均数等

package com.atguigu.java;
/*
 * 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
 *
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 *
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 *
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        int[] arr = new int[10];

        for(int i = 0;i < arr.length;i++){
            arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
        }

        //遍历
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //求数组元素的最大值
        int maxValue = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(maxValue < arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("最大值为：" + maxValue);

        //求数组元素的最小值
        int minValue = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(minValue > arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值为：" + minValue);
        //求数组元素的总和
        int sum = 0;
        for(int i = 0;i < arr.length;i++){
            sum += arr[i];
        }
        System.out.println("总和为：" + sum);
        //求数组元素的平均数
        int avgValue = sum / arr.length;
        System.out.println("平均数为：" + avgValue);
    }
}

3.数组的赋值与复制

int[] array1,array2;
array1 = new int[]{1,2,3,4};

3.1 赋值：
array2 = array1;
如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

3.2 复制：
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

4.数组元素的反转

    //方法一：
//        for(int i = 0;i < arr.length / 2;i++){
//            String temp = arr[i];
//            arr[i] = arr[arr.length - i -1];
//            arr[arr.length - i -1] = temp;
//        }

        //方法二：
//        for(int i = 0,j = arr.length - 1;i < j;i++,j--){
//            String temp = arr[i];
//            arr[i] = arr[j];
//            arr[j] = temp;
//        }

5.数组中指定元素的查找：搜索、检索

5.1 线性查找：
实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
适用性：具有普遍适用性。
5.2 二分法查找：
实现思路：每次比较中间值，折半的方式检索。
适用性：（前提：数组必须有序）

6.数组的排序算法

理解：
1）衡量排序算法的优劣：
时间复杂度、空间复杂度、稳定性

2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）

3）不同排序算法的时间复杂度

4）手写冒泡排序

    int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};

        //冒泡排序
        for(int i = 0;i < arr.length - 1;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;
                }

            }

        }