JAVA数组的高级操作

1.二分查找

步骤

1，定义两个变量，表示要查找的范围。默认min=0，max=最大索引
2，循环查找，但是min＜=max

3.计算出mid的值
4.判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
5.如果要查找的值在mid的左半边，那么min值不变，max=mid-1，继续下次循环查找
6.如果要查找的值在mid的右半边，那么max值不变，min=mid+1，继续下次循环查找
7.当min>max时，表示要查找的元素在数组中不存在，返回-1

代码实现

public class MyBinarySearch {
    public static void main(String[] args){
        int [] arr={1,2,3,4,5,6,7,8,9,10};
        int number=3;
        int index=binarySearchForIndex(arr,number);
        System.out.println(index);
    }

    private static int binarySearchForIndex(int[] arr, int number) {
        //定义查找的范围
        int min=0;
        int max=arr.length-1;
        //2.循环查找 min<=max
        while(min<=max){
            //3.计算出中间位置mid
          int mid=(min+max)>>1;
            //mid指向的元素>number
            if(arr[mid]>number){
                //表示要查找的值在左边
                max=mid-1;
            } else if (arr[mid]<number) {
                //mid指向的元素==number
                //表示要查找的元素在右边
                min=mid+1;
            }else{
                //mid指向的元素<number
                return mid;
            }
        }
        return -1;
    }

}

2.冒泡排序

步骤

1.相邻两个元素两两比较，大的方右边，小的放左边，找到最大值
2.第一次循环结束，最大值已经找到，在数组最右边
3.下一次只要在剩余元素找最大值就可以了
4.如果有n个数据进行排序，总共需要比较n-1次
5.每一次比较完备，下一次的比较就会少一个数据参与

代码实现

public class MyBubbleSort {
    public static void main(String[] args){
        int [] arr ={3,5,2,1,4 };
        //1 2 3 4 5
        bubbleSort(arr);
    }

    private static void bubbleSort(int[] arr) {
            //外层循环控制的是次数 比数组的长度少一次
        for (int i = 0; i < arr.length-1; i++) {
            //内层循环就是实际循环比较的
            //-1是为了让数组不要越界
            //-i每轮结束之后，我们就会少比一个数字
            for(int j = 0; j < arr.length-1-i; j++){
                if(arr[j]> arr[j +1]){
                    int temp= arr[j];
                    arr[j]= arr[j +1];
                    arr[j +1]=temp;
                }
            }
        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for(int i = 0; i< arr.length; i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

3.递归

指方法定义中调用方法本身的现象

public class MyFactorial {
    public static void main(String[] args){
        int sum=getSum(100);//求1~100的和//5050
        System.out.println(sum);
    }

    private static int getSum(int i) {
        //1~100之间的和
            //100+(1~99之间的和)
                //100+(1~98之间的和)
                    //......
                        //1
        //方法的作用：求1~i之间和
        if(i==1){
            return 1;
        }
        else{
            return i+getSum(i-1);
        }
    }
}

案例：递归求阶乘

5！=5*4*3*2*1

递归出口：1！=1

递归规则：n！=n*(n-1)!

public class MyFactorial {
    public static void main(String[] args){
       int result=getJc(5);
       System.out.println(result);
    }
    private static int getJc(int i) {
        //找到出口
        if(i==1){
            return 1;
        }
        else{
            //递归规则
            return i*getJc(i-1);
        }
    }
}

4.快排

快速排序算法中，每一次递归时以第一个数为基准数，找到数组中所有比基准数小的，再找到所有比基准数大的。小的全部放左边大的全部放右边，确定基准数的正确位置

 快排核心代码

public class MyQuiteSort {
    public static void main(String[] args){
        //1.从右开始找比基准数小的
        //2.从左开始找比基准数大的
        //3.交换两个值的位置
        //4.红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
        //5.基准数归位
        int[] arr={6,1,2,7,9,3,4,5,10,8};
        quiteSort(arr,0,arr.length-1);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

    private static void quiteSort(int[] arr, int left, int right) {
        int left0=left;
        int right0=right;
        //计算基准数
        int baseNumber=arr[left0];
        while(left!=right) {
            //1.从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            //2.从左开始找比基准数大的
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            //3.交换两值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //基准数归位
        int temp=arr[left];
        arr[left]=arr[left0];
        arr[left0]=temp;
    }
}

完整代码

public class MyQuiteSort {
    public static void main(String[] args){
        //1.从右开始找比基准数小的
        //2.从左开始找比基准数大的
        //3.交换两个值的位置
        //4.红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
        //5.基准数归位
        int[] arr={6,1,2,7,9,3,4,5,10,8};
        quiteSort(arr,0,arr.length-1);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

    private static void quiteSort(int[] arr, int left, int right) {
        if(right<left){
            return;
        }
        int left0=left;
        int right0=right;
        //计算基准数
        int baseNumber=arr[left0];
        while(left!=right) {
            //1.从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            //2.从左开始找比基准数大的
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            //3.交换两值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //基准数归位
        int temp=arr[left];
        arr[left]=arr[left0];
        arr[left0]=temp;
        quiteSort(arr,left0,left-1);
        quiteSort(arr,left+1,right0);
    }
}

5.Arrays

Arrays类包含用于操作数组的各种方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组
public static int binarySearch(int[] a,int key)	利用二分查找返回指定元素的索引

import java.util.Arrays;

public class MyArrays {
    public static void main(String [] args){
        //public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
        //int [] arr={3,2,4,6,7};
        //System.out.println(Arrays.toString(arr));

        //public static void sort(int[] a)	按照数字顺序排列指定的数组
        //int [] arr={3,2,4,6,7};
        //Arrays.sort(arr);
        //System.out.println(Arrays.toString(arr));
        //public static int binarySearch(int[] a,int key)	利用二分查找返回指定元素的索引
        int [] arr={1,2,3,4,5,6,7,8,9,10};
        int index=Arrays.binarySearch(arr,7);
        System.out.println(index);
        //1.数组必须有序
        //2.如果要查找的元素存在，那么返回的是这个元素实际的索引
        //3.如果要查找的元素不存在，那么返回的是（-插入点-1）
            //插入点：如果这个元素在数组中，他应该在哪个索引上
    }
}