java学习day05-day06-数组综合应用（冒泡排序）

今日目标：

排序算法
Arrarys工具类
二维数组
查找算法

1.冒泡排序：

如何将一组数实现升序（降序）排列？

private static void maopao() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想要输入十个的数字(正整数)：");
        int a[] = new int[10];
        for (int i = 0; i <= (a.length - 1); i++) {//给数组赋值
            a[i] = sc.nextInt();
        }
        for (int i = 1; i <=a.length-1 ; i++) {//开始冒泡排序
            for (int j = 0; j <=a.length-1-i ; j++) {  //j从0开始计时，所以要减i
                if (a[j]>a[j+1]){
                    int b=a[j];
                    a[j]=a[j+1];
                    a[j+1]=b;
                }
            }
        }
        System.out.println("从小到大依次排序为：");
        for (int i = 0; i <=a.length-1 ; i++) {
            System.out.print(a[i]+"  ");
        }
    }

private static void maopao2() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想要输入十个的数字(正整数)：");
        int a[] = new int[10];
        for (int i = 0; i <= (a.length - 1); i++) {
            a[i] = sc.nextInt();
        }
        for (int i = 0; i a[j+1]){
                    int b=a[j];
                    a[j]=a[j+1];
                    a[j+1]=b;                               
                }
            }
        }
        System.out.println("从小到大依次排序为：");
        for (int i = 0; i <=a.length-1 ; i++) {
            System.out.print(a[i]+"  ");
        }
    }

选择排序

private static void xuanze() {
        int a[]={98,45,65,2,8,87,31,12,3,4};
        for (int i=0;i

快速排序

//快速
    private static int [] quickSort(int arr[],int l,int r) {
        int X=arr[l];
        int i=l,j=r;
        while (iX){
                j--;
            }
            //从左向右，找出比X大的数的下标
            while (il){
            arr=quickSort(arr,l,i-1);
        }
        if(j+1

一: 冒泡与选择的区别

1.冒泡排序是比较相邻位置的两个数，而选择排序是按顺序比较，找最大值或者最小值；

2.冒泡排序每一轮比较后，位置不对都需要换位置，选择排序每一轮比较都只需要换一次位置；

3.冒泡排序是通过数去找位置，选择排序是给定位置去找数；

二: 冒泡排序优缺点

1.优点:比较简单,空间复杂度较低，是稳定的；

2.缺点:时间复杂度太高，效率慢；

三: 选择排序优缺点

1.优点：一轮比较只需要换一次位置；

2.缺点：效率慢，不稳定（举个例子6，10，6，2，9 我们知道第一遍选择第一个元素6会和2交换，那么原序列中2个6的相对位置前后顺序就破坏了）。

案例：
1.使用冒泡排序对输入的5名学员成绩进行降序排列
2.升序排列一个数组，倒序打印输出。{1,22,33,45,25,18}

2.Arrays类的常用方法（第六天）

1.equals() 比较两个数组的元素是否完全一致，返回的是true/false
2.Sort() 升序排序
3.toString 将一个数组转换成字符串类型，并用【】保护起来。
4.fill() 将数组中所有的元素用一个新的数值全部替换。
5.copyOf() 复制一份，如果数值大于数组长度将会给后面的数赋0，小于则会是前面的数
6.binarySearch() 找元素对应的下标，前提是数组已经升序排列好

字符串比较用equal以及==的区别

private static void fun1() {
        int a[]={1,2,3};
        Arrays.fill(a,6);
        System.out.println(Arrays.toString(a));
        for (int i = 0; i 

 private static void fun2() {
        int a[]={1,2,3};
        int a1[]= Arrays.copyOf(a,6);
        int a2[]= Arrays.copyOf(a,3);
        int a3[]= Arrays.copyOf(a,2);
        System.out.println(Arrays.toString(a1));
        System.out.println(Arrays.toString(a2));
        System.out.println(Arrays.toString(a3));
        System.out.println(Arrays.equals(a,a2));//true
        System.out.println(a==a2);//false
        System.out.println(a.equals(a2));//false
    }

private static void fun3() {
        int a[]={10, 20,30,40,50,60};
        int i=Arrays.binarySearch(a,30);
        int i1=Arrays.binarySearch(a,10);
        int i2=Arrays.binarySearch(a,60);
        int i3=Arrays.binarySearch(a,0);
        int i4=Arrays.binarySearch(a,15);
        int i5=Arrays.binarySearch(a,35);
        int i51=Arrays.binarySearch(a,36);
        int i6=Arrays.binarySearch(a,61);
        int i61=Arrays.binarySearch(a,100);
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
        System.out.println(i51);
        System.out.println(i6);
        System.out.println(i61);
    }

自己写一个方法。
要求：1.两个参数（数组，和查找的值）
2.如果数组中包含查找的值，返回对应的下标，
3.如果数组中不包含查找的值，返回正确的负数，表示对于的区间范围
前提也是默认该数组为升序的数组

案例：使用Arrays类升序排列一组字符，并查找某个特殊字符在升序后数组中的位置

3.二维数组

变量 数组 二维数组
随着数据量的不断增大，我们需要更大的容器来装数据，这个时候，一维内存已经不足以满足所需，我们需要的是二维“平面”数组。画图分析。

第一个【】代表的是：这个二维数组由几个一维数组构成，也是这个二维数组的长度
第二个【】代表的是，构成这个二维数组的一维数组，它的长度是多少

1.二维数组的定义：

2.二维数组的赋值：

 private static void one() {
        int  a[][];
        a=new int[3][];
        int a2[][]=new int[3][];
        int a3[][]=new int[3][5];
    }

private static void two() {
        int b,c[][]=new int[2][4];
        int a[][]=new int[3][5];
        a[0][0]=1;
        a[0][3]=2;
        a[1][0]=3;
        a[2][2]=4;
        for (int i=0;i

 private static void two() {
        int b,c[][]=new int[2][4];
        int a[][]=new int[3][5];
        a[0][0]=1;
        a[0][3]=2;
        a[1][0]=3;
        a[2][2]=4;
        for (int i=0;i

总结：
二维数组初始化的三种方式：
打个比方：酒店订餐：要么人全部到场，安排座位，要么告诉我，需要几桌。

案例：
已知有3个班级各5名学员，请使用二维数组动态录入所有学员成绩，并计算各个班级的总成绩。

4.二分查找法

定义一个有序数组，折半比较
注意，当只剩下最后两个元素时，如何避免死循环。

递归实现

循环实现

 public static void main(String[] args) {
        int a[]={1,10,30,50,80,91};
        int x=80;
        int start=0;
        int end=a.length-1;
        search(a, x, start, end);//递归
        //search1(a,x);//循环
    }

    private static void search1(int a[],int x) {//循环实现
        int start=0,end=a.length-1,mid=(start+end)/2;
        while (start<=end){
            if (x==a[mid]){
                System.out.println("找到了，下标是："+mid);
                return;
            }else if (x>a[mid]){
                start=mid+1;
            }else {
                end=mid-1;
            }
            mid=(start+end)/2;
        }
        System.out.println("找不到这个数");

    }

    private static void search(int a[],int x,int start,int end) {//递归实现
        int mid=(start+end)/2;
        if (x==a[mid]){
            System.out.println("找到了，下标是："+mid);
            return;
        }else if (x>a[mid]){
            start=mid+1;
        }else {
            end=mid-1;
        }
        if (start<=end){
            search(a, x, start, end);
        }else {
            System.out.println("找不到这个数");
        }
    }

考试

本次考试均为手写题
1.定义两个变量，分别赋值，交换两个变量的值并输出。(两种方式，每个5分)
2.输入一个学员的成绩，输出四种结果：优秀，良好，及格，不及格； 90分-100优秀， 90-80分良好，80-60分及格，60分以下不及格
3.三种方式定义一个一维数组{1,2,3,4,5}
4.写出二维数组的定义 （声明，分配长度） 存值（3种），取值
5.定义一个数组，{3,2,4,5,7,8,9,0,1,7}，求出最大值和最小值
6.同样定义上面的数组，使用冒泡排序和选择排序，对数组进行升序。
7.使用二分查找法，查找{1,2,3,5,7,9}中是否存在X=8；
分值：
1-3 每题10分
4-5 每题15分
6-7 每题20分

作业

1.利用冒泡排序和选择排序，对以下数组进行升序和降序 {1,5,12,36,55,78,98}

 private static void fun1() {
        int a[]=new int[]{1,5,12,99,55,78,98};
        System.out.println("原数组为：");
        for (int i=0;ia[j+1]){
                    int b=a[j];
                    a[j]=a[j+1];
                    a[j+1]=b;
                }
            }
        }
        for (int i=0;ia[minIndear]){
                    minIndear=j;
                }
            }
            int b=a[i];
            a[i]=a[minIndear];
            a[minIndear]=b;
        }
        for (int i=0;i

2.使用Arrays类升序排列数组{1,5,12,36,55,78,98}，请用户输入一个要查找的数字，判断是否存在该数字，如果存在，输出它在升序后数组中的位置，不存在，输出提示信息。

private static void fun2() {
        int a[]={1,5,12,36,55,78,98};
         Arrays.sort(a);
        System.out.print("升序后的数组为：");
        for (int i = 0; i a[mid]){
                start=mid+1;
            }else {
                end=mid-1;
            }
            mid=(start+end)/2;
        }
        System.out.println("找不到该数字：");
    }

3.已知有3个班级各5名学员，请使用二维数组动态录入所有学员成绩，并计算各个班级的平均成绩，最好成绩和最差成绩。依次输出，平均成绩最好的班，三个班所有学员中成绩最高的分数，最差的分数。

private static void fun3() {
        double a[][]= new double[3][5];
        Scanner sc=new Scanner(System.in);
        int b=0;//计数器

        for (int i = 0; i a[i][j]?d1:a[i][j];
                e1=e1a[i][j]?gaofen:a[i][j];//最高分
                difen=difen

4.使用二分查找法，实现第二题。

5.编写Java程序，实现输出1~100中所有不能被7整除的数，并求其和。当累加和大于4000时，记录当前数，跳出循环。要求：每输出4个数换行显示。

private static void day0605() {
        int sum=0;
        int b=0;
        for (int i=1;i<=100;i++){

            if (i%7!=0){
                sum+=i;
                System.out.print(i+" ");
                b++;
            }
            if (b%4==0){
                if (i%14==0){
                    continue;
                }
                System.out.println();
                //System.out.println("----------"+b);
            }
            if (sum>4000){
                System.out.println();
                System.out.println(sum);
                break;
            }
        }
    }

选做
1.按照一定的规则选举班长，规则如下：将班里的N个人围城一圈，顺序编号，从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，然后从下一个人重新开始，最后留下的那个人就被选为班长，请问按照这个规则，选出的班长是原来编号为第几号的学生，假设班上有25个人

private static void fun6() {
        int a[]=new int[25];
        for (int i = 0; i 

2.打印杨辉三角形（要求打印10行），如下所示：（使用二维数组）

周六周日记得复习，巩固，还有劳逸结合！

Java学习顺序