菜鸟先飞之JAVA之数组（包含冒泡排序、插入排序、二分法）

一、数组

在内存空间划出一串连续的空间（数组是一个变量，存储相同数据类型的一组数据）

数组基本要素：

1、标识符 ：驼峰命名规则——>数组名

2、数组元素 ——>值

3、元素下标：从0开始，数组中的每个元素都可以通过下标来访问

4、元素类型：数组中所有元素数据类型相同——>类型（Object[]//最大的数据类型）

5、数组长度（0~长度-1 ——为元素下标）数组名.length（数组长度固定不变，避免数组越界）

二、使用数组的步骤

1、声明数组（就是在内存空间划出一层房间）

int[] a;                     数据类型[] 数组名 = new数据类[大小]；

2、分配空间         

 //边声明边赋值不能指定数组长度；

a=new int[5];

scores =new——>分配空间 int[30];

avgAge=new int[6];

name =new String[30];

3、赋值

/*未赋值的情况会有默认值，

整型默认值0，

小数默认值0.0；

char类型默认值空字符；

boolean默认值false；

String默认值null（什么都没有）；*/

a[ 0 ]=8;

scroe[0]=89;

int[ ]=scros=={60,80,90,70,85};

int sum =0;

double avg;

for（int i=0//；i<=scores.lenth;i++）{

    //sores[i]=input.nextDouble();

    sum=sum+scros[i];

}

avg=sum/scores.length;

集合赋值法：（声明、分配空间和赋值一起）！！！必须在同一个语句中进行；

int a[]={1,2,3,4,5}//这种情况不用new，也不用指定长度；

数组越界；只要不在正常的范围内使用（运行期异常）

4、处理数据

a[ 0 ]=a[ 0 ]*10;

public class Xue5 {
    public static void main(String[] args) {
        //int a;//变量的声明
        //a=1;//变量的赋值、初始化
        //a=2;//变量的重新赋值
        //a++;//变量的运算；
        //System.out.println(a);数据的使用
        int []arr;//数组的声明
        arr=new int[5];//分配空间必须指定长度
        arr[0]=1;//对第一个元素的赋值
        //System.out.println(arr[1]);//未赋值的情况会有默认值，整形默认值0，小数默认值0.0；char类型默认值空字符；boolean默认值false；String默认值null（什么都没有）；
        arr[1]=2;//对第二个元素进行赋值
        arr[2]=3;
        arr[3]=4;
        arr[4]=5;
        //arr[5]=6;//数组长度越界
        System.out.println(arr[0]);
    }
}

三、在数组中插入新的数据，要求排序不变

1、将成绩保存在数组中；

2、通过比较找到插入位置

3、该位元素往后移一位

4、插入新成绩

**
 * @Auther Huang qinjie
 * @Date 2020/4/6
 * @Descripion
 * 插入排序
 * 外层从前向后，把一个值当基准值
 * 内层从当前值开始，从后向前，依次比较
 * 比当前值大的，向后移，比当前值小的，当前值在后方插入
 * 如果一直没有插入，则在首位插入
 */
public class Charupaixu{
    public static void main(String[] args) {
        int []a=new int[5];
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i <a.length; i++) {
            a[i]=(int)(Math.random()*100);
            System.out.println("第"+(i+1)+"位学员的成绩："+a[i]);
        }
        System.out.println(Arrays.toString(a));
        for (int i = 1; i < a.length; i++) {
            int temp=a[i];
            boolean flag=false;
            for (int j = i-1; j>=0; j--) {
                if (a[j]>=temp){
                    a[j+1]=temp;
                    flag=true;
                    break;
                }else{
                    a[j+1]=a[j];
                }
            }
            if (!flag){
                a[0]=temp;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

四、数组的使用（增删改查）

1、增加元素

2、删除元素

3、修改：重新赋值

4、查询：遍历

// 遍历数组的方法 

方法1： int arr[] = new int[3]; 

             for (int a = 0; a < arr.length; a++) { 

                System.out.println(arr[a]); 

        }

方法2：for (int a : arr) { System.out.println(a); }

//二分法查找

/**
 * @Auther Huang qinjie
 * @Date 2020/4/6
 * @Descripion
 * 二分查找
 * 从中间开始往两边分解查找     要查找的值——基准值
 * 前提：数值是升序排列
 * 1、找到中间值
 * 2、中间值与中间值进行比较
 * a、基准值与中间值相等，则找到了，break；
 * b、基准值比中间值大，开始下标定为中间值begin=mid；
 * c、基准值比中间值小，结束下标定为中间值end=mid
 * 3、重复上面的过程也没办法符合2.a，则基准值不在数组内；
 * 4、如果数组只剩一个元素
 */
public class Erfenfa {
    public static void main(String[] args) {
        int[]a={1,3,5,7,9,11,13};
        int b=1;
        int end=a.length;//数组的结束位置+1；
        boolean isFind=false;
        for (int begin = 0; begin <end ;) {//如果begin=end,代表数组中已经没有元素l；
            int mid=((begin+end)/2);
            if (b==a[mid]){
                isFind=true;
                System.out.println("在下标为："+mid+"位置找到：");
                break;
            }else if(b>a[mid]){
                begin=mid;
            }else {
                end=mid;
            }
            if (end-begin==1){
                if (b==a[begin]){
                    isFind=true;//数组只剩一个元素的情况，判断是否是查找的那个数
                    System.out.println("在下标为:0位置找到；");
                }
                break;
            }
        }if (!isFind){
            System.out.println("不存在！");
        }
    }
}

五、数组排序：

1、冒泡排序：双重循环，内层循环每循环一轮，确定一个最值，然后外层循环控制不断的重复内层循环，直到数组有序。

/**
 * @Auther Huang qinjie
 * @Date 2020/4/6
 * @Descripion
 * 冒泡升序
 */
public class MaoPao {
    public static void main(String[] args) {
        int[]a=new int[6];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(a));
        for (int i = 0; i <a.length-1 ; i++) {
            for (int j = 0; j <a.length-1-i ; j++) {
               if (a[j]>a[j+1]){
                   int temp=a[j];
                   a[j]=a[j+1];
                   a[j+1]=temp;
               }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

 //冒泡降序
public class MaoPao{
    public static void main(String[] args) {
        int[]a=new int[6];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(a));
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                if (a[j]<a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

六、求最值

打擂台：定义一个变量tmp，与数组的每一个元素进行比较，tmp如果不满足最值的情况，把当前元素重新赋值给tmp。循环结束即可获得最值。