数组

是一种用于存储多个相同数据类型的存储模型

定义

静态初始化

int [] arr = {1,8,12,3,5,9};
int arr2 [] = {1,8,12,3,5,9};//创建一个长度为6的数组 内容为{}中的值

动态初始化

int [] arr = new int [10];//创建一个长度为10的数组 内容为默认值

使用

arr[0]=11;//给下标为0的元素 赋值11
int num = arr[1];//将下标为1元素的值 赋值给num

二位数组

定义

int [] [] arr = {{1,2,3},{1,5},{2,3,4,5}};// 创建一个二维数组 内容为{{}}指定
int [] [] arr = new int[3][4];//创建一个 二维数组 其中存放的数组长都为4 共3组

使用

arr[0][1]=11;//给下标为[0][1]的元素 赋值11 第0组中下标为1的元素赋值
int num = arr[2][1];//将下标为[2][1]元素的值 赋值给num

数组的遍历

//一维数组的遍历
int [] arr = new arr [10]; 
for (int i = 0;i<arr.length;i++){     
    System.out.println(arr[i]);
 }
//二维数组的遍历
int [] [] path = {
                {1,2,3,4},
                {5,6,7,8},
                {9,10,11,12},
                {13,14,15,16},
        };
for (int i = 0;i<path.length;i++){
       for (int j = 0; j < path[i].length; j++) {
            System.out.print(path[i][j]+ " ");
        }
        System.out.println();
}

数组的乱序

//一维数组      
Random rand = new Random();
        int temp=0;
        for (int i = 0;i<arr.length;i++){   
                int x = rand.nextInt(arr.length);//获得随机下标
                temp=path[i];
                path[i]=path[x];
                path[x]=temp;
            }
        }
//二维数组      
Random rand = new Random();
        int temp=0;
        for (int i = 0;i<path.length;i++){
            for (int j = 0; j < path[i].length; j++) {
                int x = rand.nextInt(path.length);//获得随机组号
                int y = rand.nextInt(path[x].length);//根据  <组号>  随机  <组中>    的下标 
                temp=path[i][j];
                path[i][j]=path[x][y];
                path[x][y]=temp;
            }
        }

冒泡排序

算法描述:两两比较 把这轮的最大值放到最后 经过多轮的比较 数组有序

普通冒泡

    public static void bubble11( int[] arr) {
        //最多比较length-1趟  最后1趟是有序的
        for (int i = 0; i < arr.length-1; i++) {//控制比较的轮数  
            //倒数第二个 和最后一元素比较 后 最后一个无需比较 
            for (int j = 0; j < arr.length-1; j++) {//控制每轮的比较 确保每次的最大值排到该轮的最后
                if (arr[j]> arr[j+1]){
                    arr[j]= arr[j+1]+ arr[j];
                    arr[j+1]= arr[j]- arr[j+1];
                    arr[j]= arr[j]- arr[j+1];
                }
            }
        }
    }

优化冒泡

1.改变数组有序后 轮数 不到最大值 继续比较的问题

2.改变 每次比较需要比较到 最后一个元素的问题

3.两边同时比较 减少 每趟 比较的次数 (end-begin)次

  public static void bubble3(int[] arr)    {
        int left;
        int right;
        int leftpos=0;//下一次开始的位置
        int rightpos=arr.length-1;//下一次结束的位置
        for (int i = 0; i < arr.length-1; i++) {
            int count =0; //不执行 无效循环
            left=leftpos;
            right=rightpos;
            //往右挑最大 和 记录下一次结束的位置
            for (int j = left+1; j < right; j++) {
                if (arr[j]>arr[j+1]){
                    arr[j]= arr[j+1]+ arr[j];
                    arr[j+1]= arr[j]- arr[j+1];
                    arr[j]= arr[j]- arr[j+1];
                    count++;
                    rightpos=j;
                }
            }
            //往左挑最小 和 记录下一次开始的位置
            for (int j = right; j >left; j--) {
                if (arr[j]< arr[j-1]){
                    arr[j]= arr[j-1]+ arr[j];
                    arr[j-1]= arr[j]- arr[j-1];
                    arr[j]= arr[j]- arr[j-1];
                    count++;
                    leftpos=j;
                }
            }
            //不执行 无效循环
            if (count==0){
               return;
            }
        }

选择排序

算法描述:每轮取得最小值 放到已排好序的数组后面 经过多轮的挑选 数组有序

    public static void select (int arr[]){
        for (int i = 0; i < arr.length-1; i++) {//控制第几轮比较 
            int min=arr[i];
            ///minIndex 必须=i  =0时 当该轮第一个值是 最小值时出错 for if 没有进去 修改minIndex值
            int minIndex=i;
            //获得本次的最小值的索引
            for (int j = i+1; j < arr.length; j++) {
                if (min>arr[j]){
                  minIndex =j;
                }
            }
            //该轮的 第一个数 和 该轮中的 最小值 交换
           	min=arr[minIndex];
            arr[minIndex]=arr[i];
            arr[i]=min;
            //第一轮比较后第一个数据有序
        }
    }

二分法遍历数组

要求遍历的数组必须升序

算法描述: 判断一个数是否存在 通过不断缩小(二分)比较的下标范围 来<快速>确定该数是否存在

    public boolean  isExsit (int[] arrSortUP,int serchNum){
        boolean flag = false;
        int left =0;
        int right = arrSortUP.length;
        //通过不断改变 左右下标的值 来缩小值所在的范围 最差 直到 left=right 确定值所在
        while(left<=right){
            int mid = (left+right)/2;
            if (arrSortUP[mid]==serchNum){
                return flag=true;
            }
            if (arrSortUP[mid]<serchNum){
                left=mid+1;
            }
            if (arrSortUP[mid]>serchNum){
                right=mid-1;
            }
        }
        return flag;
    }