十大排序的Java实现以及横向对比、时间复杂度

十大排序算法的java代码实现以及横向对比、时间复杂度

源代码地址（github地址）：https://github.com/Lining128/Sort

排序算法是《数据结构与算法》中最基本的算法之一。

排序算法可以分为内部排序和外部排序。

内部排序是数据记录在内存中进行排序。

而外部排序是因为排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

1.冒泡排序

1.1 算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的事情，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

1.2 java代码实现

/**
 * @author Lining
 * 冒泡排序
 * @date 2020/3/21 15:23
 */
public class BubbleSort{
    public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j + 1] < array[j]) {  //相邻元素两两相比
                    int temp = array[j + 1];  //元素交换位置
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
                return array;
    }
}

1.3时间复杂度

T(n) = O(n²)

1.4空间复杂度

O=1

2.选择排序

2.1 算法步骤

在没有排序的序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已经排序的序列的末尾，一直循环，直到排列完毕。

2.2 java代码实现

/**
 * @author Lining
 * 选择排序
 * @date 2020/3/21 15:34
 */
public class selectionSort{
    public static int[] selectionSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
        int temp = array[minIndex];
        array[minIndex] = array[i];//交换位置
        array[i] = temp;
        }
        return array;
    }
}

2.3时间复杂度

T(n) = O(n²)

2.4空间复杂度

O=1

3.插入排序

3.1 算法步骤

构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入

3.2 java代码实现

/**
 * 插入排序
 * @author Lining
 * @date 2020/3/21 15:55
 */
public class insertionSort {
    public static int[] insertionSort(int[] array) {
        if (array.length == 0)
            return array;
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];//插入数字
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        return array;
    }
}

3.3时间复杂度

T(n) = O(n²)

3.4空间复杂度

O=1

4.希尔排序

4.1 算法步骤

希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

4.2 java代码实现

/**
 * 希尔排序
 * @author Lining
 * @date 2020/3/21 16:00
 */
public class ShellSort {
    public static int[] ShellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }
}

4.3时间复杂度

T(n) = O(n log n)

4.4空间复杂度

O=1

5.归并排序

5.1 算法步骤

将已经有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

5.2 java代码实现

import java.util.Arrays;

/**
 * 归并排序
 * @author Lining
 * @date 2020/3/21 16:09
 */
public class MergeSort {
    public static int[] MergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(MergeSort(left), MergeSort(right));
    }
    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
    */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
    }
}

5.3时间复杂度

T(n) = O(n log n)

5.4空间复杂度

O=n

6.快速排序

6.1 算法步骤

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.2 java代码实现

/**
 * 快速排序
 * @author Lining
 * @date 2020/3/21 16:14
 */
public class QuickSort {
    public static int[] QuickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            QuickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            QuickSort(array, smallIndex + 1, end);
        return array;
    }
    public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }
    /**
     * 交换数组内两个元素
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

6.3时间复杂度

T(n) = O(n log n)

6.4空间复杂度

O=log n

7.堆排序

7.1 算法步骤

堆排序是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7.2 java代码实现

/**
 * 堆排序
 * @author Lining
 * @date 2020/3/21 16:18
 */

public class HeapSort {
    public static void adjustHeap(int[] data,int i, int len) {
        int temp, j;
        temp = data[i];
        for (j = 2 * i; j < len; j *= 2) { //沿关键字较大的孩子结点向下筛选
            if (j < len && data[j] < data[j + 1]) {
                ++j; //j为关键字中较大记录的下标
            }
            if (temp >= data[j]) {
                break;
            }
            data[i] = data[j];
            i = j;
        }
        data[i] = temp;

    }
    

    public static void heapSort(int[] data) {
        int i;
        for (i = data.length / 2 - 1; i >= 0; i--) { //构建一个大顶堆
            adjustHeap(data, i, data.length - 1);
        }
        for (i = data.length - 1; i >= 0; i--) { //将堆顶记录和当前未经排序子序列的最后一个记录交换
            int temp = data[0];
            data[0] = data[i];
            data[i] = temp;
            adjustHeap(data, 0, i - 1); //将a中前i-1个记录重新调整为大顶堆
        }

    }
}

7.3时间复杂度

T(n) = O(n log n)

7.4空间复杂度

O=1

8.计数排序

8.1 算法步骤

计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

8.2 java代码实现

import java.util.Arrays;

/**
 * 记数排序
 * @author Lining
 * @date 2020/3/21 16:51
 */
public class CountingSort {
    public static int[] CountingSort(int[] array) {
        if (array.length == 0) return array;
        int bias, min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max)
                max = array[i];
            if (array[i] < min)
                min = array[i];
        }
        bias = 0 - min;
        int[] bucket = new int[max - min + 1];
        Arrays.fill(bucket, 0);
        for (int i = 0; i < array.length; i++) {
            bucket[array[i] + bias]++;
        }
        int index = 0, i = 0;
        while (index < array.length) {
            if (bucket[i] != 0) {
                array[index] = i - bias;
                bucket[i]--;
                index++;
            } else
                i++;
        }
        return array;
    }
}

8.3时间复杂度

T(n) = O(n+k)

8.4空间复杂度

O=k

9.桶排序

9.1 算法步骤

假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排。

9.2 java代码实现

import java.util.ArrayList;

/**
 * 桶排序
 * @author Lining
 * @date 2020/3/21 
 */
public class BucketSort {
    public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
        if (array == null || array.size() < 2)
            return array;
        int max = array.get(0), min = array.get(0);
        // 找到最大值最小值
        for (int i = 0; i < array.size(); i++) {
            if (array.get(i) > max)
                max = array.get(i);
            if (array.get(i) < min)
                min = array.get(i);
        }
        int bucketCount = (max - min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < array.size(); i++) {
            bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketSize == 1) { // 如果带排序数组中有重复数字时
                for (int j = 0; j < bucketArr.get(i).size(); j++)
                    resultArr.add(bucketArr.get(i).get(j));
            } else {
                if (bucketCount == 1)
                    bucketSize--;
                ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
                for (int j = 0; j < temp.size(); j++)
                    resultArr.add(temp.get(j));
            }
        }
        return resultArr;
    }
}

9.3时间复杂度

T(n) = O(n+k)

9.4空间复杂度

O=n+k

10.基数排序

10.1 算法步骤

假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排。

10.2 java代码实现

import java.util.ArrayList;

/**
 * 基数排序
 * @author Lining
 * @date 2020/3/23
 */
public class RadixSort {
    public static int[] RadixSort(int[] array) {
        if (array == null || array.length < 2)
            return array;
        // 先算出最大数的位数
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            max = Math.max(max, array[i]);
        }
        int maxDigit = 0;
        while (max != 0) {
            max /= 10;
            maxDigit++;
        }
        int mod = 10, div = 1;
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < 10; i++)
            bucketList.add(new ArrayList<Integer>());
        for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
            for (int j = 0; j < array.length; j++) {
                int num = (array[j] % mod) / div;
                bucketList.get(num).add(array[j]);
            }
            int index = 0;
            for (int j = 0; j < bucketList.size(); j++) {
                for (int k = 0; k < bucketList.get(j).size(); k++)
                    array[index++] = bucketList.get(j).get(k);
                bucketList.get(j).clear();
            }
        }
        return array;
    }
}

10.3时间复杂度

T(n) = O(n x k)

10.4空间复杂度

O=n+k