经典数组排序

冒泡排序

元素两两笔记，把大的往后挪，经过一轮比较后，最大的元素会出现在最后面。
如此往复，就可以把数组中的元素拍后

 int[] arr = {24, 69, 80, 57, 13, 5, 0, -1, 40}; // 13 24 57 69 80
        //对数组中的元素，进行一个从小到大的排序
        //冒泡排序：元素两两笔记，把大的往后挪，经过一轮比较后，最大的元素会出现在最后面。
        //如此往复，就可以把数组中的元素拍后
        //快速抽取一段代码到方法中 ctrl+alt+M
        // tuiDao(arr);
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    //交换元素位置
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }

        System.out.println(Arrays.toString(arr));
    }

选择排序

从第一个元素开始，挨着跟后面的每一个元素进行比较，小的往前放，经过一轮比较后，最小的元素会放到最前面如此往复，数组元素从小到大就排好了

int[] arr = {24, 69, 80, 57, 13,6,9,0};
        //tuiDao(arr);
        for (int index = 0; index <arr.length-1; index++) {
            for (int i = 1 + index; i < arr.length; i++) {
                if (arr[index] > arr[i]) {
                    int t = arr[index];
                    arr[index] = arr[i];
                    arr[i] = t;
                }
            }
        }

        System.out.println(Arrays.toString(arr));
    }

直接插入排序

每次把后面的一个元素，插入到前面的一个有序序列中，使之保持仍然有序

 int[] arr = {50, 20,0,20,1,4,3};
        //[20, 50,0]
        //代码实现
        //外层循环定义轮次
        for (int i = 1; i < arr.length; i++) {
            //里层循环，比较交换位置
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }

希尔排序

他是对直接插入排序的优化

int[] arr = {50, 20, 10, 2, 0, -1, 20, 30, 90, 100};

        for ( int gap = arr.length / 2;gap>0;gap/=2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j--) {
                    if (arr[j] < arr[j - gap]) {
                        int t = arr[j];
                        arr[j] = arr[j - gap];
                        arr[j - gap] = t;
                    }
                }
            }
            System.out.println(Arrays.toString(arr));

快速排序

 //获取 把数组分为左右两区的这个基准数的索引
  /*
    1.将基准数挖出形成第一个坑。
    2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    4.再重复执行2，3两步骤。*/    
    public static void quickSort(int[] arr, int startIndex, int endIndex) {
        if (startIndex < endIndex) {
            //获取基准数的索引
            int index = getIndex(arr, startIndex, endIndex);
            //对左右两区进行递归调用
            quickSort(arr, startIndex, index - 1); //对左区进行递归
            //对右区进递归
            quickSort(arr, index + 1, endIndex);//对右区进行递归
        }

    }

 //挖坑填数                                   //  0             9
    private static int getIndex(int[] arr, int startIndex, int endIndex) {
        //定义变量结束起始索引和终止索引
        int i = startIndex;
        int j = endIndex;
        //定义一个基准数

        int x = arr[startIndex];
        while (i < j) {  //外层 重复2 3 步骤
            //2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while (i < j && arr[j] >= x) { //从后往前找，如果这个数比基准点大 就往后退
                j--; //让j往后退
            }
            //填坑
            if (i < j) {
                arr[i] = arr[j];
                i++; //顺变让i自增一下
            }
  //3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] < x) { //从后往前找，如果这个数比基准点大 就往后退
                i++; //让i往前跑
            }
            //填坑
            if (i < j) {
                arr[j] = arr[i];
                j--; //顺变让j再递减一下
            }
        }
 arr[i] = x; //把基准数添加最后一个坑位
        //arr[j]=x;
        return i;
    }      

二分查找

为了快速找到，数组中一个元素所对应的索引,前提是该数组中的元素必须有序，才能用二分查找二分查找的原理：每次拿这个元素跟中间元素去比较，这样查找的次数就会减少一半
基本查找：从头开始挨个找,找到该元素第一次出现的索引

public static void main(String[] args) {
        int[] arr = {20, 30, 58, 59, 90, 98, 100};
       
        //int index=findIndex(arr,58);
        // System.out.println("该元素的索引是："+index);
        int index = findIndex2(arr, 100);
        System.out.println("该元素的索引是：" + index);
    }

    //二分查找
    private static int findIndex2(int[] arr, int ele) {
        //定义最小索引
        int minIndex = 0;
        //定义最大索引
        int maxIndex = arr.length - 1;
        //定义中间索引
        int centerIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (ele == arr[centerIndex]) {
                return centerIndex;
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            }
            //再重新计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }        return -1;

    }

    //根据元素找索引
    private static int findIndex(int[] arr, int ele) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == ele) {
                return i;
            }
        }
        return -1;// 找不到，喜欢返回 -1 代表没有找到
    }

Arrays 数组工具类

 //这个类包含用于操作数组（如排序和搜索）的各种方法。
    int[] arr={20,50,90,98,100,200,0,3,8,90,50,60,98};
    //二分查找：前提是元素有序
  //  int index = Arrays.binarySearch(arr, 300);
  //  System.out.println(index);

    //排序数组 升序排列
    Arrays.sort(arr);

    String s = Arrays.toString(arr);
    System.out.println(s);

    //对比两个数组中的元素是否一模一样
    int[] arr2 = {20, 50, 90,30};
    int[] arr3 = {20, 50, 90};
    boolean equals = Arrays.equals(arr2, arr3);
    System.out.println(equals);


***Arrays.fill();***
 int[] arr={10,20,30,40,50,60};
       // Arrays.fill(arr,0,2,100);
       // System.out.println(Arrays.toString(arr));

       // static int[] copyOf ( int[] original, int newLength)
       // 复制指定的数组，截断或填充零（如果必要）所以副本具有指定的长度。

        int[] ints = Arrays.copyOf(arr, 3);
        System.out.println(Arrays.toString(ints));

       // copyOfRange( long[] original, int from, int to)
        //将指定的数组指定的范围复制到一个新的数组中。

        int[] ints1 = Arrays.copyOfRange(arr, 3, arr.length);

        System.out.println(Arrays.toString(ints1));

public static void fill ( int[] a,int toIndex,int val)
将指定的int值 为指定数组的每个元素对象的指定范围。范围是从指数 fromIndex填充，包容延伸，指数 toIndex，独家。（如果 fromIndex==toIndex，范围是满是空的。）
参数a - 数组填充fromIndex - 第一个元素的索引（含）充满指定值toIndex - 最后一个元素的索引（独家）充满指定值val - 被存储在数组的所有元素的值异常
如果 fromIndex >toIndex IllegalArgumentException
ArrayIndexOutOfBoundsException - 如果 fromIndex< 0 或 toIndex >a.length*/