Java学习Day07(第三章数组结束，开始第四章面向对象)

3.4 数组中涉及到的常见算法

1.数组元素的赋值（杨辉三角，回型数等）

杨辉三角

package atguigu.exer;
//杨辉三角
public class ArrayDemo2 {
    public static void main(String[] args) {
        //1.声明并初始化二维数组
        int[][] arr = new int[10][];
        //2.给数组的元素赋值
        for(int i = 0;i < arr.length;i++){
            arr[i] = new int[i + 1];

             //2.1给首末元素赋值
            arr[i][0] = 1;
            arr[i][i] = 1;
            //2.2给每行的非首末元素赋值
            //if(i > 1){
                for(int j = 1;j < arr[i].length - 1;j++){
                    arr[i][j] = arr[i-1][j-1] + arr[i-1][j];

                }
            //}
        }            
        //3.遍历二维数组
        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();
        }

    }
}

2.求数值型数组中元素的最大值，最小值，平均数，总和等

package com.atguigu.java;
/*
 * [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]);
            System.out.println();
        }    
        //求数组元素的最大值
        int maxValue = 0;
        for(int i = 0;i < arr.length;i++){
            if(maxValue < arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("最大值为： " + maxValue);
        //求数组元素的最小值
        int minValue = arr[0];
        for(int i = 0;i < arr.length;i++){
            if(minValue > arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值为： " + minValue);
        //求数组元素的总和
        //sum
        //求数组元素的平均数
        //double avgValue = sum/arr.length;
    }
}

3.数组的复制，反转，查找（线性查找，二分法查找）

复制，翻转，查找

package atguigu.exer;

public class ArrayExer1 {
    public static void main(String[] args){
        int[] arr1,arr2;
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        //显示arr1的内容
        for(int i = 0;i < arr1.length;i++){
            System.out.print(arr1[i] + "\t");
        }
        //复制
        arr2 = new int[arr1.length];
        for(int i = 0;i < arr2.length;i++){
            arr2[i] = arr1[i];
        }
        //赋值arr2变量等于arr1
        //不能称作数组的复制
        //arr2 = arr1;
        //修改arr2中的偶索引元素，使其等于索引值
        for(int i = 0;i <arr2.length;i++){
            if(i % 2 == 0){
                arr2[i] = i;

            }
        }

        System.out.println();
        for(int i = 0;i < arr1.length;i++){
            System.out.print(arr1[i] + "\t");
        //数组的反转
        }

    }


}

package atguigu.exer;

public class ArrayExer2 {
    public static void main(String[] args){
        //数组的反转
        String[] arr = new String[]{"a","b","c","d","e","f"}; 
        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;i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        //查找（搜索）
        //线性查找：
        System.out.println();
        String dest = "b";
        boolean isFlag = true;
        for(int i = 0;i < arr.length;i++){
            if(dest.equals(arr[i])){
                System.out.println("找到了指定元素，位置为: " + i);
                isFlag = false;
                break;
            }
        }
        if(isFlag){
        System.out.println("很遗憾，没有找到");
        }
        System.out.println("*********************");
        //二分法查找：(熟悉)
        //前提：索要查找的数组必须有序。
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

        int dest1 = -34;
        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean isFlag1 = true;
        while(head <= end){

            int middle = (head + end)/2;

            if(dest1 == arr2[middle]){
                System.out.println("找到了指定元素，位置为： " + middle);
                isFlag1 = false;
                break;

            }else if(arr2[middle] > dest1){
                end = middle - 1;

            }else{//arr[middle] < dest1
                head = middle + 1;
            }
        }
        if(isFlag1){
            System.out.println("没有找到");
        }

    }    
}

4.排序算法

（1）时间复杂度：分析关键字的比较次数和记录的移动次数
（2）空间复杂度：分析排序算法中需要多少辅助内存
（3）稳定性：若两个记录A和B的关键字值相等，但排序后A,B的先后次序保持不变，则称这种排序算法是稳定的。
排序算法分类：内部排序和外部排序
需要借助外部存储器的叫做外部排序

Java学习Day07(第三章数组结束，开始第四章面向对象)

3.4 数组中涉及到的常见算法

1.数组元素的赋值（杨辉三角，回型数等）

杨辉三角

2.求数值型数组中元素的最大值，最小值，平均数，总和等

3.数组的复制，反转，查找（线性查找，二分法查找）

复制，翻转，查找

4.排序算法

冒泡排序

3.5 Arrays工具类的使用

3.6 数组使用中的常见异常

4.面向对象

4.1 面向过程和面向对象

类中属性的使用

类中方法的使用和说明

全站热榜

创作者周榜