03.数组及其经典算法

数组：

数组是相同类型数据的有序集合。数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成。
基本特点：

不能同时静态初始化又动态初始化，即:

int[] arr = new int[2]{1,2};会报错

数组特点

• 长度确定，一把被创建，大小就是不可改变的。
• 数组内元素必须是相同类型
• 数组类型可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。Java中对象时存储在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身都是在堆中存储。

type[]   arr_name; //（推荐使用这种方式）
type    arr_name[];//部分语音已经不支持这种声明方式

int [] arr01 = new int[10];

数组的声明和初始化：数组的声明只在栈当中开辟一块内存数组变量，堆里面什么都没有。只有在初始化的时候才会在堆中开辟一块空间。

静态初始化

在定义数组同时就给数组元素分配空间并赋值。

int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

动态初始化

将数组的定义，为数组元素分配空间和赋值分开操作。

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null

foreach循环

该循环仅用于读取数组元素的值，不能修改本数组内元素的值，每一个temp都是数组内元素的一个副本，并不是原来的数组元素。

temp只是一个临时变量，和原来的数组内的元素没有任何关联。输出的结果还是原数组

数组中的删除本质上还是拷贝。

public static String[] arrayDelete(String[] s, int index){
        System.arraycopy(s,index+1,s,index,s.length-(index + 1));
        s[s.length - 1] = null;
        for(int i = 0; i<s.length; i++){
            System.out.println(i + "--" + s[i]);
        }
        return s;
    }

数组的扩容

本质上是先定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中

public static String[] arrayExtand(String [] s1,int length){
        String [] s2 = new String [s1.length+10];
        System.arraycopy(s1,0,s2,0,s1.length);
        return s2;
    }

数组的插入

本质上是先定一个更大的数组，然后将原数组内容分两段拷贝到新数组中，然后插入想要插入的元素

public static String[] arrayInsert(String [] s1, String s, int index){
        String [] s2 = new String [s1.length+1];
        System.arraycopy(s1,0,s2,0,index);
        s2[index] = s;
        System.arraycopy(s1,index,s2,index+1,s1.length - index);
        return s2;
    }

java.util.Array

导入java.util.Array包。

二维数组

int[][] a  = new int[3][];
        a[0] = new int[]{20,30};
        a[1] = new int[]{10,15,80};
        a[2] = new int[]{11,22,80};

        int[][] b = {
                {20,30,40},
                {50,20},
                {100,200,300,400}
        };
        System.out.println(b[2][3]);

输出结果是400.

二维数组的本质就是一维数组，数组中的元素指向另一个数组。注意下标是从0开始。

冒泡排序法

    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.len - 1; i++) {//确定比较次数
            for (int j = i; j < arr.length; j++) {//依次与后边的元素比较，最值上浮
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

        }
        for (int i : arr) {
            System.out.print(i + "  ");
        }
    }

选择排序法

    public static void selectSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {//确定每一次循环数组头都是最值
            for (int j = i + 1; j < arr.length; j++) {//与后面的元素进行比较
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i + "  ");
        }
    }

插入排序法

public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int pos = i;	//记录要插入的位置
            int curr = arr[i];	//记录该元素的值
            for (int j = i-1; j >= 0; j--) {
                if(curr >= arr[j]){
                    break;
                }
                if(curr < arr[j]){
                    arr[j + 1] = arr[j];
                    pos--;
                }
            }
            if(pos != i){	//如果位置更改了就插入
                arr[pos] = curr;
            }
        }
        for (int i : arr) {
            System.out.print(i + "  ");
        }
    }

小总结：

冒泡排序算法是外层循环确定循环次数，内层循环依次与后一个元素进行比较,以类似于水中泡泡向上浮的形式进行排序。选择排序法是外层循环确定次数，以及确保该位置的元素是最值，内层循环依次进行元素比较，选择其中最值的放入位置。插入排序是最容易出错的排序算法，注意的是外层循环为要插入的元素，内层循环时已经排序好了的数组，外层元素依次往其中插入。声明变量pos记录要插入的位置，变量curr记录插入元素的值并且与排序好的元素进行比较，如果第一次比较就是失败的，可以直接退出，因为内层循环的都是已经排序好了的。注意循环条件是用curr进行比较。

二分法查找算法：
二分法是可以从中间开始比较的，我一开始碰到存在于数组中的数字它给我返回了-1，以为错误在于mid = (high + low)认为是否是因为mid并非是中间数，例如（0+9）/2=4,那么这样一来从第四个数字开始比较是不够完美的（不明确中间数是哪个）。但是其实mid是用来作为数组的下标，也就是第五个数字，二分法是完整的二分，另外，因为mid是int型的变量，所以它的结果是去尾法的整型结果。实际上我碰到的错误是将while(low <= high)中的等于号忘记了，这就导致了有存在的数值会漏掉，比如当数组中只有一个元素时，low = high 但是此时如果没有等号会直接返回-1；（ps：当碰到return语句时，会直接跳出函数，所以return下一行有如break语句不会被执行)

public static int BinarySearch(int[] arr, int value) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (value == arr[mid]) {
                return mid;
            }
            if (value < arr[mid]) {
                high = mid - 1;
            }
            if (value > arr[mid]) {
                low = mid + 1;
            }

        }

        return -1;
    }