Java实现十大排序算法

十大排序算法

十大排序算法分别为：冒泡排序、快速排序、插入排序、希尔排序、选择排序、堆排序、归并排序、桶排序、计数排序、基数排序

他们的时间复杂度分别为：

关于时间复杂度

平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。

线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；

O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序

线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

• n：数据规模
• k："桶"的个数
• In-place：占用常数内存，不占用额外内存
• Out-place：占用额外内存
• 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

---

冒泡排序

冒泡排序是基于交换排序的典型， 是快速排序思想的基础，是一种稳定的排序算法。它的时间复杂度为O(n²)

思路：循环遍历多次每次从前往后把大元素往后调，每次确定一个最大(最小)元素，多次后达到排序序列。(或者从后向前把小元素往前调)。

实现方式：

public static void bubble(int[] arr) {
   
        for (int i = 1; i < arr.length; i++) {
   
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
   
                if (arr[j] > arr[j + 1]) {
   
                    arr[j] = arr[j] + arr[j + 1];
                    arr[j + 1] = arr[j] - arr[j + 1];
                    arr[j] = arr[j] - arr[j + 1];

                    flag = false;
                }
            }
            if (flag) {
   
                break;
            }
        }
    }

---

快速排序

快速排序是对冒泡排序的一种改进，采用递归分治的方法进行求解。而快排相比冒泡是一种不稳定排序,时间复杂度最坏是O(n²),平均时间复杂度为O(n log n),最好情况的时间复杂度为O(n log n)。

对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

思路：

• 从数列中挑出一个元素，称为 “基准”（pivot）;

• 分区：将比这个数大或等于的数放在它的右边，小于它的数放在它的左边

• 再对左右区间重复第二步，直到各区间只有一个数

具体步骤：选择一个基准数，这个基准数的位置记为第一个坑 从后往前寻找比他小的数字，找到的第一个比他小的数字则挖走填入到前一个坑中，此时挖走数据，则形成了一个新的坑，然后从前往后找比他大的数，找到的第一个也填到上一个挖走数字的坑中。以此类推，直到无法再查询。

注意：每找到一个数，就换一个方向，并且把这个数字填到上一次挖出的坑中

实现方法：

class QuickSort {
   
    public void quickSort(int[] arr, int start, int end) {
   
        // 找出分左右两区的位置索引位置，然后对左右两区进行递归调用
        if (start < end) {
   
            int index = getIndex(arr, start, end);
            // 对左区递归
            quickSort(arr, start, index - 1);
            // 对右区递归
            quickSort(arr, index + 1, end);
        }
    }

    private static int getIndex(int[] arr, int start, int end) {
   
        int i = start;
        int j = end;
        int x = arr[i];
        while (i < j) {
   
            // 从后往前找，如果找出来的数比基准数大，则让 j--
            while (i < j && arr[j] >= x) {
   
                j--;
                // 当 j<i 或者 arr[j]<x 则跳出循环
                // 跳出循环如果 i<j ，则说明找到了比基准数小的数
            }
            if (i < j) {
   
                // 将这个数字填入到上一个坑
                arr[i] = arr[j];
                // 由于上一个坑已经被填入，所以需要 i++
                i++;
            }

            // 从前往后找比基准数小的数字
            while (i < j && arr[i] < x) {
   
                i++;
            }
            if (i < j) {
   
                arr[j] = arr[i];
                j--;
            }
        }
        // 此时 i 和 j相等，arr[i]与arr[j]都是一样的
        // 把基准数放到最后一个坑
        arr[i] = x;

        // 返回索引位置
        return i;
    }
}

---

插入排序

插入排序是一种最简单的排序方法，他是将一个数据插入到一个长度为m的有序表中，并且让他保持有序性

从1索引处开始，将后面的元素插入到之前的有序列表中，并且使之保持有序。

class FastSort {
   
    // 外层循环定义轮次
    public void fastSort(int[] arr) {
   
        // 因为是从1索引处开始插入，所以这里 i 要从1开始
        for (int i = 1; i < arr.length; i++) {
   
            // 里层循环进行比较插入
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
   
                arr[j] = arr[j] + arr[j - 1];
                arr[j - 1] = arr[j] - arr[j - 1];
                arr[j] = arr[j] - arr[j - 1];
                j--;
            }
        }
    }
}

// 或者

class FastSort {
   
    // 外层循环定义轮次
    public void fastSort(int