java常见算法

1.二分查询法

要求待查询的序列是有序数列, 每个取中间位置的值与目标值进行比较

• 如果目标值 > 中间位置, 目标值在右部分, 起始索引更新为mid + 1
• 如果目标值 = 中间位置, 则直接返回
• 如果目标值 < 中间位置, 目标值在左部分, 结束索引更新为mid - 1

public static void main(String[] args) {
    // 正向排序数组
    int[] arr = new int[]{1, 3, 6, 9, 11, 21, 43, 55, 78};
    search(arr, 9);
}

public static void search(int[] arr, int t) {
    // 起始索引
    int start = 0;
    // 结束索引
    int end = arr.length - 1;
    // 判断查询了几次
    int count = 1;

    while (start <= end) {  // 设置边界值
        // 找到中间索引
        int mid = (start + end) / 2;
        // 输出: 每次进行比较的中间值
        System.out.println(arr[mid]);
        if (arr[mid] == t) {
            System.out.println("找到目标值:" + t);
            System.out.println("查找次数" + count);
            return;
        } else if (arr[mid] < t){
            // 目标值在右部分, 起始索引更新为mid + 1
            start = mid + 1;
        } else if (arr[mid] > t) {
            // 目标值在左部分, 结束索引更新为mid - 1
            end = mid - 1;
        }
        // 进入下一次循环, 查找次数 + 1
        count ++;
    }
    System.out.println("无匹配值");
}

2.冒泡排序算法

通过重复比较相邻的元素并交换它们的位置，将未排序部分中的最大（或最小）元素逐渐“冒泡”到序列的一端，忽略序列中已经排好序的元素, 重复上面的过程, 直到整个序列有序

案例: 数组有9个元素, 我们想要其中的元素从小到大有序排列

外层循环: 0
内层循环: 0:1, 1:2, 2:3, 3:4, 4:5, 5:6, 6:7, 7:8 (0索引与1索引比较; 1索引与2索引比较)

外层循环: 1
外层循环: 0:1, 1:2, 2:3, 3:4, 4:5, 5:6, 6:7

外层循环: 2
外层循环: 0:1, 1:2, 2:3, 3:4, 4:5, 5:6

......

外层循环: 7
外层循环: 0:1

public static void main(String[] args) {
    int[] arr = new int[]{65, 12, 3, 9, 11, 51, 23, 45, 58};

    bubbleSort(arr);
    for (int a : arr) {
        System.out.println(a);
    }
}

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        System.out.println("外层遍历, 当前批次 =" + i);
        // 外层遍历
        for (int j = 0; j < arr.length - 1 - i; j++) {
            System.out.println("内存遍历, 当前批次 =" + j);
            /**
             * 内存遍历, 比较相邻的元素
             * 忽略队列中已经排行的元素, 重复整个过程
             */
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

3.快速查询算法

案例: 将数组的奇数放在前面，偶数放在后面

public static void main(String[] args) {
    int[] arr = new int[]{65, 12, 3, 9, 11, 51, 23, 45, 58};

    evenOdd(arr);
    for (int a : arr) {
        System.out.println(a);
    }
}

public static int[] evenOdd(int[] arr){
    int  left = 0;
    int right = arr.length - 1;
    while(left < right){
        while(left < right && arr[left] % 2 != 0){
            // 左侧游标, 如果是奇数, 就向右移动游标(left++), 指向后一个对象, 直到那个偶数
            left++;
        }
        while(left < right && arr[right] % 2 == 0){
            // 右侧游标, 如果是偶数, 就向左移动游标(right--), 指向前一个对象, 直到找到奇数
            right--;
        }

        // 交换两个对象
        if(left < right){
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
    }
    return arr;
}