玖雨y的算法刷题记录day13——排序算法-CSDN博客

本文链接：https://blog.csdn.net/LLLLuanYH/article/details/140990155

玖雨y的算法刷题记录day13——排序算法

本篇介绍三种较为基础的排序算法：冒泡排序、选择排序、堆排序，首先给出三种排序算法的时间复杂度、空间复杂度以及其他特征。

算法	最好	最坏	平均	空间	稳定	思想	注意事项
冒泡	$O (n)$	$O(n^2)$	$O(n^2)$	$O (1)$	Y	比较	最好情况需要额外判断
选择	$O(n^2)$	$O(n^2)$	$O(n^2)$	$O (1)$	N	比较	交换次数一般少于冒泡
堆	$O (n l o g n)$	$O (n l o g n)$	$O (n l o g n)$	$O (1)$	N	选择	堆排序的辅助性较强，理解前先理解堆的数据结构

接下来给出三种排序算法的 Java 实现代码

冒泡排序

import java.util.Arrays;

public class BubbleSort {

    public static void bubble(int[] arr) {
        int j = arr.length - 1;
        do {
            int x = 0;
            for (int i = 0; i < j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    x = i;
                }
            }
            j = x;
        } while (j != 0);
    }


    public static void main(String[] args) {
        int[] arr = {5, 4, 3, 2, 1};
        System.out.println(Arrays.toString(arr));
        bubble(arr);
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

import java.util.Arrays;

public class ChooseSort {

    public static void choose(int[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            int max = i;
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[max]) {
                    max = j;
                }
            }
            if (max != i) {
                int temp = arr[i];
                arr[i] = arr[max];
                arr[max] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 4, 3, 2, 1};
        System.out.println(Arrays.toString(arr));
        choose(arr);
        System.out.println(Arrays.toString(arr));
    }
}

堆排序

import java.util.Arrays;

public class HeapSort {

    public static void sort(int[] arr) {
        heapify(arr, arr.length);
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            down(arr, 0, i);
        }
    }


    // 建堆 O(n)
    private static void heapify(int[] arr, int size) {
        for (int i = size / 2 - 1; i >= 0; i--) {
            down(arr, i, size);
        }
    }

    // 下潜
    private static void down(int[] arr, int parent, int size) {
        while (true) {
            int left = 2 * parent + 1;
            int right = 2 * parent + 2;
            int max = parent;
            if (left < size && arr[left] > arr[max]) {
                max = left;
            }
            if (right < size && arr[right] > arr[max]) {
                max = right;
            }
            if (max == parent) {
                break;
            }
            swap(arr, parent, max);
            parent = max;
        }
    }

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

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}