JAVA基础——数组及算法

杨辉三角

*提示：
* 1.第一行一个元素，第n行那个元素
* 2.每一行的第一个元素和最后一个元素都是1
* 3.第三行开始，对于一个非第一个元素和最后一个元素。即：
* yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j]
如图：

代码如下

 public static void yangHuiSanJiao(){

        int [][] yangHui = new int[10][];  //行的列不同，所以
        //给数组元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int [i+1];
            //每一行的首末元素
            yangHui[i][0] = 1;
            yangHui[i][i] = 1;
            if(i>1){
                for (int j = 1; j < yangHui[i].length-1; j++) {
                    yangHui[i][j] = yangHui[i-1][j-1]+yangHui[i-1][j];
                }
            }
        }
        //打印杨辉三角
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j]+"\t");
            }
            System.out.println();
        }
    }

【拓展】
1.创建一个长度为10 的int型数组，要求数组元素的值在1-30之间，且是随机赋值。同时要求元素的值各不相同。
2.正向循环输出，螺旋矩阵

求数组中的相关值

随机生成两位数在【10-99】之间的数值，求最大值、最小值、平均值、总和。
公式：【A，B】之间的随机自然数：(int) (Math.random()*(B-A+1))

public static void arrayExcel(){
        int [] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] =(int) (Math.random()*(99-10+1)+10);  //random返回的值是[0.0,1)
        }
        //最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i])
                max = arr[i];
        }
        System.out.println("最大值："+max);
        //最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i])
                min = arr[i];
        }
        System.out.println("最小值："+min);
        
        //总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和："+sum);
        //平均值
        System.out.println("平均值："+sum/arr.length);
    }

数组查找（二分法查找）

划分可以更改！！不一定要为二分法

public static void midSeach(){
        int [] arr = new int[]{-31,-20,-8,1,2,15,18,26};  //二分法必须有序
        int key = 2;
        int head = 0;
        int end = arr.length-1;
        boolean flag = true;
        while (head<=end){
            int mid = (end + head)/2;
            if(key == arr[mid]){
                System.out.println("元素已找到，位置为："+mid);
                flag = false;
                break;
            }else if (key < arr[mid]){
                end = mid - 1;
            }else{
                head = mid + 1;
            }
        }
        if(flag){
            System.out.println("没有找到该元素！！");
        }
    }

排序算法分类及常见算法

分为内部排序和外部排序
内部排序为在内存中进行排序，
外部排序数据太大必须借助外部存储器（如硬盘），常见的为多路归并排序。

1. 选择排序（直接选择排序、堆排序）
2. 交换排序（冒泡排序、快速排序）
3. 插入排序（直接插入排序、折半排序、Shell排序）
4. 归并排序
5. 桶式排序
6. 基数排序

算法的特征

1.输入（有0个或多个输入，必须描述清楚）、
2.输出（至少有一个输出）、
3.有穷性（有限循环）、
4.确定性（无二义性）、
5.可行性

排序

1.冒泡排序

    public static void bubbleSort(){
        //比较相邻元素、依次找出最大最小值
        int [] arr =new int[]{23,12,15,4,546,1,245,35,4,15};
        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+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }

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

2.快速排序

经过一轮第一个元素把数组分为两半，该元素前都是小于该元素的的数、后边都是大于该元素的数

代码为完善

3.堆排序

4.归并排序

排序算法性能比较

算法名称	时间复杂度	时间复杂度(最坏)	时间复杂度(最好)	空间复杂度	稳定性
选择排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定
堆排序	O(n log2n)	O(n log2n)	O(n log2n)	O(1)	不稳定
插入排序	O(n2n2)	O(n2n2)	O(n)	O(1)	稳定
希尔排序	O(n1.3)	O(n2)	O(n)	O(1)	不稳定
冒泡排序	O(n2)	O(n2)	O(n)	O(1)	稳定
快速排序	O(n log2n)	O(n2)	O(n log2n)	O(log2n)	不稳定
归并排序	O(n log2n)	O(n log2n)	O(n log2n)	O(n)	稳定

数组Arrays工具类

sort()、 equals() 、fill() 、binarySearch()、 toString()等方法

 public static void arraysUtils(){
        int [] arr =new int[]{23,12,15,4,546,1,245,35,4,15};
        int [] arr1 =new int[]{23,121,15,4,546,1,245,35,4,15};
        System.out.println(arr.equals(arr1));
        System.out.println(Arrays.toString(arr));  //返回数组中的所有元素
        Arrays.sort(arr);      //数组排序
        System.out.println(Arrays.toString(arr));
        Arrays.fill(arr,10);  //替换填充数组中的元素
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));

        int a = Arrays.binarySearch(arr1,546);  //返回数组中的位置index
        System.out.println(a);

    }

数组异常

1.空指针异常

数组未赋值或者赋值为null，则会出现空指针异常

    错误一
    int []arr2 = new int[3];
    arr2 = null;
    System.out.println(arr2[0]);   //空指针异常
    //错误二
    int [][] arr3 = new int[4][];
    System.out.println(arr3[0][0]);   //空指针异常
    System.out.println(arr3[0]); //返回值为null


    //错误三
    String [] arr4 = new String[]{"aa","bb","cc"};
    arr4[0] = null;
    System.out.println(Arrays.toString(arr4));  //null，bb,cc
    System.out.println(arr4[0].toString());  //空指针异常`

2.数组边界异常

数组角标越界