java语言--------javaSE之数组常见操作

数组常见操作

数组高级冒泡排序原理

冒泡排序原理:相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

需求：
数组元素：{24, 69, 80, 57, 13}
请对数组元素进行排序。

public static void main(String[] args) {
     int[] arr = {24, 69, 80, 57, 13};
    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));
}

数组高级选择排序原理

选择排序原理
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

public static void main(String[] args) {
    //选择排序：每次拿一个元素，跟后面剩余的元素，挨个比较，小的往前放，经过一轮比较后，最小的元素就会出现在最前面。
    int[] arr = {24, 69, 80, 57, 13,20,30,5,6};
    //tuiDao(arr);
    //第二轮 从1索引处开始

    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));
}

直接插入排序

案例说明：

public class MyTest3 {
    public static void main(String[] args) {
        //直接插入排序：从第二个元素，每次拿一个后面元素插入之前的有序列中，使之仍保持有序
        //  [4,2,3,5,9,5,6,10,20]
        //  [4]2,3,5,9,5,6,10,20
        //  [2,4] 3, 5, 9, 5, 6, 10, 20
        // [2,3,4] 5, 9, 5, 6, 10, 20
        //[2,3,4,5]  9, 5, 6, 10, 20
        int[] arr = {49, 38, 5, 97, 76, 13, 27};
        //外层循环定义轮次
        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));
    }
}

挖坑填数

public class MyTest {
    public static void main(String[] args) {
        int[] arr={20,20,6,8,9,1,2,3,4,90,100,3,0,-1,-2,6,9};
        QuickSrotUtils.quickSrot(arr,0,arr.length-1);

        System.out.println(Arrays.toString(arr));
    }
}
public class QuickSrotUtils {
    private QuickSrotUtils() {
    }

    public static void quickSrot(int[] arr, int start, int end) {
        //递归调用左右两区
        if (start < end) {
            //获取分左右两区的那个位置索引
            int index = getIndex(arr, start, end);
            //对左区递归
            quickSrot(arr, start, index - 1);
            //对右区递归
            quickSrot(arr, index + 1, end);
        }
    }

    //挖坑填数：
  /*  1.将基准数挖出形成第一个坑。
    2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    4.再重复执行2，3两步骤。*/
    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //1.定义基准数
        int x = arr[i];
        //重复2 3  步
        while (i < j) {
            //2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while (i < j && arr[j] >= x) {
                j--;
            }
            if (i < j) {
                arr[i] = arr[j];
                i++;//顺便让i增一下
            }
            //3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] < x) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                //顺便让j减一下
                j--;
            }
        }
        //把基准数，填到最后一个坑中
        arr[i] = x;
        return i;
    }
}

二分查找

二分查找：前提数组元素必须有序
二分查找的思想：每一次都查中间的那个元素，比较大小就能减少一半的元素。

public class MyTest {
    public static void main(String[] args) {
        //查找该元素在数组中第一次出现的索引
        //基本查找：从头开始挨个往找。
        int[] arr = {10, 20, 30, 40, 50, 60, 90};
        //int index = getIndex(arr, 90);
        //二分查找的前提：数组元素有序。
        int index = getIndex2(arr, 40);
        System.out.println(index);
    }
    //二分查找
    private static int getIndex2(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]) {
                maxIndex = centerIndex - 1;
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            }
            //记得再次计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }

) {
minIndex = centerIndex + 1;
}
//记得再次计算中间索引
centerIndex = (minIndex + maxIndex) / 2;
}
return -1;
}

ider快速抽取方法Ctrl + Alt + M