数组的学习（偷懒还没有学完）

数组

数组的出现，是为了我们更加方便的操作数据。

数组是存储同一种数据类型多个元素的集合，也可以看做一个容器。

数组既可以存储基本数据类型，也可以存储引用数据类型

数组的定义格式：数据类型【】 数组名

​ 数据类型 数组名【】

一般使用这种方式去定义数组int[] arr=new int[10];

初始化

Java中的数组必须先初始化后才可以使用

所谓初始化，就是为数组中的数据元素分配内存空间，并且为每一个元素赋值。

数组初始化分为动态初始化和静态初始化

package amount;

public class Demo01 {
    public static void main(String[] args) {
        //数组的定义
        int[] arr=new int[10];

        //动态初始化
        int[] arr1=new int[10];
        //静态初始化
        int[] arr2=new int[]{1,2,3,4,5,6};
        double[] arr3={2.5,4.4,6.6};
    }
}

数组的常见操作

ArrayIndexOutOfBoundsException数组常见异常，数组下标越界异常。

package amount;

public class Demo02 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,};
        //for循环遍历数组
        for (int i = 0; i <arr.length; i++) {
            System.out.print(arr[i]);

        }
        System.out.println();
        //获取数组元素最大值或者最小值
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max<arr[i]){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}

反转数组在Java学习中有！！

二维数组

二维数组：其实就是数组元素为一维数组的数组

package amount;

public class Demo03 {
    public static void main(String[] args) {
        //3的意思是我们定义了一个二维数组，他的长度为三
        //2的意思是我们二维数组里面有三个一维数组，每一个一维数组长度为2
        int[][] arr=new int[3][2];
    }
}

package amount;

public class Demo04 {
    public static void main(String[] args) {
        //对一个二维数组进行求和
        int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int num=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                num=num+arr[i][j];


            }
        }
        System.out.println(num);
    }
}

二分查找，也就是折半查找

每次折一半进行比较，然后让最左边等于中间值加一或者让最右边等于中间值减一。

排序

冒泡排序

原理：数组元素两两比较，交换位置，大元素往后放，一轮之后，最大的元素便会确定下来。

package amount;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        int[] arr={20,0,666,78,56,66,0315,1566,6};
        maopao(arr);
        System.out.println(Arrays.toString(arr));

    }
    public static void maopao(int[] arr){
        for (int j = 0; j < arr.length-1; j++) {


        for (int i = 0; i < arr.length-1-j; i++) {
            if (arr[i]>arr[i+1]){
               int num=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=num;
            }
        }
        }
    }
}

选择排序

从数组0下标开始，依次和后面的元素进行比较，选出最小的元素放在0下标处，0下标原来的元素和最小的元素进行交换。

package amount;

import java.util.Arrays;

public class Demo06 {
    //选择排序
    public static void main(String[] args) {
        int[] arr={20,0,666,78,56,66,0315,1566,6};

        xuanze(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void xuanze(int[] arr){

        for (int i = 0; i <arr.length-1; i++) {
            for (int j = 0+i; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                    int num=0;
                    num=arr[i];
                    arr[i]=arr[j];
                    arr[j]=num;
                }

            }

        }
    }
}

直接插入排序

原理：对一个数组，一般假设他第一个元素为一个有序数列，然后每轮依次插入一个元素进入数列，使其保持有序。

package amount;

import java.util.Arrays;

public class Demo07 {//直接插入排序
    public static void main(String[] args) {
        int[] arr={20,0,666,78,56,66,0315,1566,6};
        zhicha(arr);
        System.out.println(Arrays.toString(arr));
    }
    //外层循环判断轮次
    //里层循环进行插入比较
    public static void zhicha(int[] arr){
        for (int i = 1; i < arr.length ; i++) {
            int j=i;
            while (j>0&&arr[j]<arr[j-1]){
                int num=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=num;
                j--;
            }

        }
    }




}

希尔排序

根据选取的增量进行分组，然后对每一个组进行排序。

对于选取的增量，可以采用数组长度的一半，然后依次减半

但是还不是很完美，我们可以使用一种叫做克努特系列来进行增量的选取

快速排序

分治法，比大小再分区

取一个基准数，比他大的放在右边，比他小的放在左边，知道每一个分区内都为一个数。