java(数组及常用简单算法 )

数组

数组：数组是存储同一种数据类型数据的集合容器。

数组的定义格式：

数据类型[]  变量名  =  new  数据类型[长度];

数组的好处：对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是：长度-1。

局部变量：如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。

成员变量：成员变量就是定义在方法之外，类之内的.

数组中最常见的问题：

1.NullPointerException 空指针异常原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

2.ArrayIndexOutOfBoundsException索引值越界。原因：访问了不存在的索引值。

数组的初始化方式：

动态初始化:
    数据类型[] 变量名 = new 数据类型[长度];

静态初始化：
    数据类型[] 变量名 = {元素1，元素2.....};

如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果数据一开始还不太明确，这时候就建议使用动态初始化。

class Demo7 {
    public static void main(String[] args) {
        //动态初始化
        //int[] arr = new int[10];

        //静态初始化
        int[] arr = {10,20,30,40,50};
        for(int index = 0 ; index<arr.length ; index++){
             System.out.print(arr[index]+",");
        }
    /*
        int[] arr = new int[50];
        Scanner scanner = new Scanner(System.in);
        for(int i  = 0 ; i< arr.length ; i++){
            arr[i] = scanner.nextInt();
        }
        */
    }
}

class Demo8 {
    public static void main(String[] args)
{
        int[] arr = {-12,-14,-5,-26,-4};
        int max = getMax(arr);
        System.out.println("最大值："+ max);
    }

    public static int  getMax(int[] arr) {
        int max = arr[0]; //用于记录最大值
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
                max = arr[i];
            }
        }
        return max;
    }
}

选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。

class Demo9 {
    public static void main(String[] args) {
        int[] arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。
        selectSort(arr);
    }

    public static void selectSort(int[] arr) {
        //把最大值放在首位置。
        for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
            for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
                if(arr[i]>arr[j]){
                    //交换位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }
    }
}

冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。

class Demo10 {
    public static void main(String[] args) {
        int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5
        bubbleSort(arr);
    }

    public static void bubbleSort(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 temp  = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }

    }
}

折半查找法(二分法): 使用前提必需是有序的数组。

class Demo12 {
    public static void main(String[] args) {
        int[] arr = {12,16,19,23,54};
        //int index = searchEle(arr,23);
        int index = halfSearch(arr,116);
        System.out.println("元素所在的索引值是："+ index);
    }
    public static int halfSearch(int[] arr, int target){
        //定义三个变量分别记录最大、最小、中间的查找范围索引值
        int max = arr.length-1;
        int min = 0;
        int mid = (max+min)/2;
        while(true){
            if(target>arr[mid]){
                min = mid+1;
            }else if(target<arr[mid]){
                max = mid -1;
            }else{
                //找到了元素
                return mid;
            }
            //没有找到的情况
            if (max<min){
                return -1;
            }
            //重新计算中间索引值
            mid = (min+max)/2;
        }

    }

    public static int searchEle(int[] arr, int target) {
        for(int i = 0 ; i<arr.length ; i++){
            if(arr[i]==target){
                return i;
            }
        }
        return -1;
    }
}

二维数组： 二维数组就是数组中的数组。

二维数组的定义格式：

数据类型[][] 变量名 = new 数据类型[长度1][长度2];

二维数组 的初始化方式：

动态初始化:
数据类型[][] 变量名 = new 数据类型[长度1][长度2];  

静态初始化：
数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}

class Demo16 {
    public static void main(String[] args) {
        int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
        //遍历二维数组
        for(int i = 0;  i <arr.length ; i++){
            for(int j = 0 ; j<arr[i].length ; j++){
                System.out.print(arr[i][j]+",");
            }
            //换行
            System.out.println();
        }
    }
}

数组的特点：

1.数组只能存储同一种数据类型的数据。

2.数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；

3.数组一旦初始化，长度固定。

4.数组中的元素与元素之间的内存地址是连续的。