面试常见算法题

二分查找，有相同的数，返回目标值下标

 public static List<Integer> method5(int[] arr, int target) {
        List<Integer> list = new ArrayList<>();
        if (arr == null) return list;

        int left = 0;
        int right = arr.length - 1;
        int mid;
        while (left <= right) {
            mid = (left + right) / 2;
            if (arr[mid] > target) {
                right = mid - 1;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                list.add(mid);
                int a = mid - 1;
                int b = mid + 1;
                while (a >= 0) {
                    if (arr[a] == target) {
                        list.add(a);
                        a--;
                    } else {
                        break;
                    }
                }

                while (b <= arr.length - 1) {
                    if (arr[b] == target) {
                        list.add(b);
                        b++;
                    } else {
                        break;
                    }
                }
                break;
            }
        }
        return list;
    }

冒泡排序

 public static void bubbleSort(int[] arr) {
        //冒泡排序  每个元素跟后面的元素相比，交换位置
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

选择排序

 public static void selectSort(int[] arr) {
        //每次都是找最小的元素，进行置换
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int minValue = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < minValue) {
                    minValue = arr[j];
                    minIndex = j;
                }
            }
            arr[minIndex] = arr[i];
            arr[i] = minValue;
        }
        System.out.println(Arrays.toString(arr));
    }

插入排序

 public static void insertSort(int[] arr) {
        //第一次把arr[0] 看成有序数组 arr[1]插入
        //第二次把arr[0]-arr[1] 看成有序数组 arr[2]插入

        for (int i = 1; i < arr.length; i++) {
            int insertValue = arr[i];
            int insertIndex = i - 1;
            while (insertIndex >= 0 && arr[insertIndex] > insertValue) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex + 1] = insertValue;
        }
        System.out.println(Arrays.toString(arr));
    }

希尔排序

 public static void hellSort(int[] arr) {
        //对插入排序的优化，比如 2345 1 ，1插入的时候要经过好几次计算
        int step = arr.length / 2;
        while (step != 0) {
            for (int i = 0; i < arr.length - step; i++) {
                if (arr[i + step] < arr[i]) {
                    int tmp = arr[i];
                    arr[i] = arr[i + step];
                    arr[i + step] = tmp;
                }
            }
            step /= 2;
        }
        System.out.println(Arrays.toString(arr));
    }

快速排序

 public static void method(int[] arr, int left, int right) {
        if (arr == null || left > right) return;
        int midValue = arr[left];
        int i = left;
        int j = right;
        while (i != j) {
            while (arr[j] >= midValue && i < j) {
                j--;
            }
            while (arr[i] <= midValue && i < j) {
                i++;
            }
            //进行交换左右两个数据
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
        //最后把midValue放到i和j相等的那个下标的位置
        arr[left] = arr[i];
        arr[i] = midValue;
        method(arr, left, i - 1);
        method(arr, i + 1, right);
    }

一级标题

二级标题

三级标题

四级标题

五级标题

六级标题