面试准备——Java排序算法【笔试，面试的核心，建议掌握】-优快云博客

本文链接：https://blog.youkuaiyun.com/mjr_l/article/details/145537409

冒泡排序

核心思想

通过多次比较相邻元素并交换位置，将最大值逐步“冒泡”到数组末尾。
时间复杂度：O(n²)（最坏、平均），O(n)（最好）。
空间复杂度：O(1)。

代码实现

public void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) break; // 提前退出优化
    }
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行冒泡排序。
答案：排序后为 [2, 3, 5, 6, 8]。

选择排序

核心思想

每次从未排序部分中找到最小值，并将其放到已排序部分的末尾。
时间复杂度：O(n²)。
空间复杂度：O(1)。

代码实现

public void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行选择排序。
答案：排序后为 [2, 3, 5, 6, 8]。

插入排序

核心思想

将未排序部分的元素逐个插入到已排序部分的适当位置。
时间复杂度：O(n²)（最坏、平均），O(n)（最好）。
空间复杂度：O(1)。

代码实现

public void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行插入排序。
答案：排序后为 [2, 3, 5, 6, 8]。

希尔排序

核心思想

改进版插入排序，通过设定间隔分组进行排序，逐步缩小间隔至 1。
时间复杂度：O(n log n) ~ O(n²)。
空间复杂度：O(1)。

代码实现

public void shellSort(int[] arr) {
    int n = arr.length;
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行希尔排序。
答案：排序后为 [2, 3, 5, 6, 8]。

归并排序

核心思想

分治法，将数组分成两半分别排序，然后合并两个有序数组。
时间复杂度：O(n log n)。
空间复杂度：O(n)。

代码实现

public void mergeSort(int[] arr, int left, int right) {
    if (left >= right) return;
    int mid = left + (right - left) / 2;
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

private void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    System.arraycopy(temp, 0, arr, left, temp.length);
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行归并排序。
答案：排序后为 [2, 3, 5, 6, 8]。

快速排序

核心思想

分治法，选择一个基准值（pivot），将数组分为小于基准值和大于基准值的两部分，递归排序。
时间复杂度：O(n log n)（平均），O(n²)（最坏）。
空间复杂度：O(log n)（递归栈）。

代码实现

public void quickSort(int[] arr, int left, int right) {
    if (left >= right) return;
    int pivotIndex = partition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
}

private int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, right);
    return i + 1;
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行快速排序。
答案：排序后为 [2, 3, 5, 6, 8]。

堆排序

核心思想

利用堆（完全二叉树）的性质进行排序，先构建最大堆，再依次取出堆顶元素。
时间复杂度：O(n log n)。
空间复杂度：O(1)。

代码实现

public void heapSort(int[] arr) {
    int n = arr.length;
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (int i = n - 1; i > 0; i--) {
        swap(arr, 0, i);
        heapify(arr, i, 0);
    }
}

private void heapify(int[] arr, int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest != i) {
        swap(arr, i, largest);
        heapify(arr, n, largest);
    }
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行堆排序。
答案：排序后为 [2, 3, 5, 6, 8]。

计数排序

核心思想

统计每个元素出现的次数，根据统计结果直接构造排序后的数组。
时间复杂度：O(n + k)，其中 k 是数据范围。
空间复杂度：O(k)。

代码实现

public void countingSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int[] count = new int[max + 1];
    for (int num : arr) {
        count[num]++;
    }
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i] > 0) {
            arr[index++] = i;
            count[i]--;
        }
    }
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行计数排序。
答案：排序后为 [2, 3, 5, 6, 8]。

桶排序

核心思想

将数据分配到多个桶中，对每个桶单独排序，最后合并。
时间复杂度：O(n + k)。
空间复杂度：O(n + k)。

代码实现

public void bucketSort(int[] arr) {
    int n = arr.length;
    List<Integer>[] buckets = new List[n];
    for (int i = 0; i < n; i++) {
        buckets[i] = new ArrayList<>();
    }
    for (int num : arr) {
        int index = num / n;
        buckets[index].add(num);
    }
    for (List<Integer> bucket : buckets) {
        Collections.sort(bucket);
    }
    int index = 0;
    for (List<Integer> bucket : buckets) {
        for (int num : bucket) {
            arr[index++] = num;
        }
    }
}

面试案例

问题：对数组 [5, 3, 8, 6, 2] 进行桶排序。
答案：排序后为 [2, 3, 5, 6, 8]。

基数排序

核心思想

按照每一位（个位、十位等）进行排序，从低位到高位依次处理。
时间复杂度：O(n * k)，其中 k 是数字的最大位数。
空间复杂度：O(n + k)。

代码实现

public void radixSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    for (int exp = 1; max / exp > 0; exp *= 10) {
        countingSortByDigit(arr, exp);
    }
}

private void countingSortByDigit(int[] arr, int exp) {
    int n = arr.length;
    int[] output = new int[n];
    int[] count = new int[10];
    for (int num : arr) {
        count[(num / exp) % 10]++;
    }
    for (int i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }
    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }
    System.arraycopy(output, 0, arr, 0, n);
}