数组排序和查找

冒泡排序

public static void main(String[] args) {
    int[] arr = {55, 35, 69, 11, 22, 66};
    maoPao(arr);
    System.out.println(Arrays.toString(arr));
}

private static void maoPao(int[] arr) {
    //冒泡排序：数组元素两两比较，大的元素往后放，经过一轮比较，最大的元素就出现在了最后面。
    //外层循环控制轮次
    for (int i = 0; i < arr.length-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;
            }
        }
    }
}

选择排序

public static void main(String[] args) {
    int[] arr = {55, 35, 69, 11, 22, 66};
    xuanZe(arr);
    System.out.println(Arrays.toString(arr));
}

private static void xuanZe(int[] arr) {
    //选择排序：从0索引处开始，拿一个元素，跟他后面的元素挨个比较，小的往前放，经过一轮比较，最小的元素就出现在了最前面。
    //外层循环控制轮次
    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;
            }
        }
    }
}

直接插入排序

public static void main(String[] args) {
    int[] arr = {55, 35, 69, 11, 22, 66};
    chaRu2(arr);
    System.out.println(Arrays.toString(arr));
}

private static void chaRu1(int[] arr) {
    //直接插入排序：将后面的元素，插入到之前的有序列表中，使之仍保持保持有序。
    //外层循环控制轮次
    for (int i = 1; i < arr.length; i++) {
        for (int j = i; j > 0; j--) {//往前继续比较
            //若当前的元素(arr[j])比前面的元素小 则交换
            if (arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
            }
        }
    }
}

private static void chaRu2(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int j = i;
        //若当前的元素(arr[j])比前面的元素小 则交换
        while (j > 0 && arr[j] < arr[j - 1]) {
            int t = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = t;
            //往前继续比较
            j--;
        }
    }
}

希尔排序

public static void main(String[] args) {
    int[] arr = {20, 14, 23, 55, 31, 1};
    //希尔排序
    XiEr(arr);
    System.out.println(Arrays.toString(arr));
    //[1, 14, 20, 23, 31, 55]
}

private static void XiEr(int[] arr) {
    //找到增量值gap gap每次减半 直到为1
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        //找到索引为0 对应gap的元素
        //每次向后自加 与自己相对应的gap元素进行比较
        //通过插入排序进行更换
        for (int i = gap; i < arr.length; i++) {
            for (int j = i; j >= gap; j-=gap) {
                if (arr[j] < arr[j-gap]){
                    int t = arr[j];
                    arr[j] = arr[j-gap];
                    arr[j-gap] = t;
                }
            }
        }
    }
}

快速排序

public static void main(String[] args) {
    int[] arr = {55, 35, 69, 11, 22, 66};
    kuaiPai(arr, 0, arr.length - 1);
    System.out.println(Arrays.toString(arr));
}

public static void kuaiPai(int[] arr, int start, int end){
    if (start < end) {
        //找出基准数的索引
        int index = getIndex(arr, start, end);
        //对左右两区进行递归调用
        //左分区
        kuaiPai(arr, start, index - 1);
        //右分区
        kuaiPai(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;
    int x = arr[i];//1.将基准数挖出形成第一个坑
    while (i < j) {

        //2.由后向前找比他小的数
        //若比基准数大或等于 则继续向前寻找
        while (i < j && x <= arr[j]) {
            j--;
        }
        //找到后挖出此数填到前一个坑中
        if (i < j) {
            arr[i] = arr[j];
            i++;//i自增 为之后避免自己与自己相比情况
        }

        //3.由前向后找比他大或等于的数找到后也挖出此数填到前一个坑中
        //若比基准数小 则继续向后寻找
        while (i < j && x > arr[i]) {
            i++;
        }
        //找到后也挖出此数填到前一个坑中
        if (i < j) {
            arr[j] = arr[i];
            j--;//j自减 为之后避免自己与自己相比情况
        }
    }
    //将基准数填入最后一个坑中 最后i和j相等
    arr[i] = x;
    //arr[j] = x;
    //返回基准数的索引
    return i;
}

二分查找

public static void main(String[] args) {
    int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    //二分查找：数组元素 必须有序
    int index = getIndex(arr, 30);
    System.out.println(index);
}

private static int getIndex(int[] arr, int ele) {
    int minIndex = 0;
    int maxIndex = arr.length - 1;
    int centerIndex = (maxIndex + minIndex) / 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 = (maxIndex + minIndex) / 2;
    }

    return -1;
}