4.Java基础第二篇(2)学习笔记、数组常见算法

1.数组的常见算法

1)、这里会直接上java开发主要掌握的常见算法，数组常见算法10个，没写的，就只是需要了解的，没必要浪费太多时间再这个上面，有算法工程师呢！
2)、数组元素的赋值（杨辉三角）

//提示：
    //①、第一行有1个元素，第n行有n个元素
    //②、每一行的第一个元素和最后一个元素都是1
    //③、从第三行开始，对于第一个元素和最后一个元素的是：yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j]
    @Test
    public void yangHuiDemo01(){
        //1.声明二维数组
        int [][] yangHui=new int[10][];

        //2.给数组元素数组赋值
        for(int i=0;i<yangHui.length;i++){
            yangHui[i]=new int[i+1];
            //2.1、给首末元素赋值
            yangHui[i][0]=1;
            yangHui[i][i]=1;
            //2.2、给非首末元素赋值
            for(int j=1;j<yangHui[i].length-1;j++){
                yangHui[i][j]=yangHui[i-1][j-1]+yangHui[i-1][j];
            }
        }

        //3.遍历二维数组
        for(int i=0;i<yangHui.length;i++){
            for (int j=0;j<yangHui[i].length;j++) {
                System.out.print(yangHui[i][j]+"  ");
            }
            System.out.println();
        }
    }

这是一道很经典的算法题（杨辉三角）。
3)、算法的考查，求数值类型中的最大值，最小值，平均数，总和；

//提示获取（a,b）随机数公式：(int)(Math.random()*(b-a+1)+a)
    //①、定义一个int的数组包含10元素，分别赋值一些随机的整数，求最大值，最小值，和值，所有随机数都是两位数
    @Test
    public void randomNumberDemo01(){
        //1.定义数组
        int[] arr =new int[10];

        //2.获取随机数
        for(int i=0;i<arr.length;i++){
            arr[i]=(int)(Math.random()*(99-10+1)+10);
        }

        //3.求数组元素的最大值
        int maxValue=arr[0];
        for(int i=1;i<arr.length;i++){
            if(maxValue < arr[i]){
                maxValue=arr[i];
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("------------------" );
        System.out.println("maxValue:"+maxValue);
        System.out.println("------------------" );

        //4.求数组元素的最小值
        int minValue=arr[0];
        for(int i=1;i<arr.length;i++){
            if(minValue > arr[i]){
                minValue=arr[i];
            }
        }
        System.out.println("minValue:"+minValue);
        System.out.println("------------------" );

        //5.求数组元素的总和
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum +=arr[i];
        }
        System.out.println("sum:"+sum);
        System.out.println("------------------" );

        //6.求数组元素的平均值
        double avgValue=sum/arr.length;
        System.out.println("avgValue:"+avgValue);
    }

4)、数组的复制，反转，查找（线性查找，二分法查找）

 @Test
    public void arrayCopyReversalLookupXDemo01(){
        //1.定义一个数组
        String arr[]=new String[]{"AA","bb","CC","DD","FF","QQ"};

        //2.数组的复制(区别在于你是指引过去，还是复制出来，变量的问题，没有new，arr=arr1就是指引过去)
        String[] arr1=new String[arr.length];
        for(int i=0;i<arr1.length;i++){
            arr1[i]=arr[i];
            System.out.println("Copy:"+arr1[i]);
        }
        System.out.println("------------------" );


        //3.数组的反转
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            String temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println("Reversal:"+arr[i]);

        }
        System.out.println("------------------" );

        //4.数组的查找
        //4.1、线性查找
        String Dest="FF";
        boolean isFlag=true;
        for(int i =0;i<arr1.length;i++){
            if (Dest.equals(arr1[i])) {//这这里用的是equals，如果是int的用==
                System.out.println("Eureka:"+i);
                isFlag=false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("sorry");
        }
        System.out.println("------------------" );

        //4.2、二分法查找（折半查找）
        //前提：二分法查找，需要数组是有序的

        //先定义一个数组
        int[] arr3=new int[]{-11,-9,-8,-1,11,55,99,102,185,333};

        //确定需要查找的值
        int dest2=333;

        //设置初始索引
        int head=0;

        //设置尾索引
        int end=arr3.length-1;

        //是否找到了
        boolean isFlag2=true;

        //主体循环,条件是头部索引小于尾部索引
        while(head<=end){

            //设置需要找的值的代号和查找方法
            int middle=(head+end)/2;

            //判断是否找到了
            if(dest2==arr3[middle]){
                System.out.println("binary search:"+middle);
                isFlag2=false;
                break;
            }else if (arr3[middle]>dest2) {
                //索引减1，如果值大于所找到的数时
                end=middle-1;
            }else if (arr3[middle]<dest2) {
                //索引加1，如果值小于所找打的数时
                head=middle+1;
            }

        }

        //如果while没有找到
        if (isFlag2) {
            System.out.println("sorry");
        }
    }

5)、冒泡排序

//思想：
    //①、比较相邻的元素，如果第一个比第二个大(升序)，就交换他们两个。
    //②、对每一个相邻元素作同样的工作，从开始第一队到结尾最后一对，这步做完最后的元素会是最大的数。
    //③、针对所有的元素重复以上的步骤，除了最后一个。
    //④、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止
    @Test
    public void sortingAlgorithmDemo01(){
        //定义一个数组
        int[] arr0=new int[]{-88,99,-7,85,-3,999,87,21,-787,77};

        //设置要循环的长度，数组长度-1
        for(int i=0;i<arr0.length-1;i++){

            //设置冒泡排序没回少一组
            for(int j=0;j<arr0.length-1-i;j++){

                //判断j是否大于i
                if(arr0[j]>arr0[j+1]){

                    //替换元素
                    int temp=arr0[j];
                    arr0[j]=arr0[j+1];
                    arr0[j+1]=temp;
                }
            }
            System.out.println("Result:"+arr0[i]);
        }
    }

6)、快速排序

 public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];

        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }

写快排也没理得太明白，尴尬！只能看别人代码来写注释，汗颜！

2.最后的废话

1)、会持续更新，欢迎指导和纠正
2)、现在再复习，所以到复习完都会更新
3)、望能帮助到需要的人
4)、如果你看到这里，请给一个关注和点赞，如果觉得可以，对你有帮助，帮忙推荐一下，如果有意见可以留下评论，后面的人走的那么艰难
5)、不是什么大牛，但你如果你需要帮助加我QQ:3451532547，我会把我知道的告诉你(如果借钱，你能先借点给我吗？就像你说的，后面有钱会还你。)
6)、数组常见算法这里一定不要死记硬背，不要死脑筋，一定要去理解再写，写后再理解，切记切记！