数据结构与算法之八种排序算法

概述

排序是将一组数据，依据指定的顺序进行排列的过程。
常见的排序算法可以分为内部排序和外部排序，内部排序指将需要处理的所有数据都加载到内部存储器(内存)中进行排序；外部排序指由于数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。
内部排序：所有排序操作都在内存中完成。
外部排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行。

冒泡排序(BubbleSort)

原理

通过对待排序序列从前向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

图解

代码实现

public static void bubbleSort(int[] arr) {
    int temp = 0;//临时变量
    boolean flag = false;//是否进行过交换
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                flag = true;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        if (!flag) {
            break;
        } else {
            flag = false;
        }
        System.out.println("第" + i + "次排序结果:" + Arrays.toString(arr));
    }
}

选择排序(SelectSort)

原理

从欲排序的数据中，按指定的规则选出某一元素，再依据规定交换位置后达到排序的目的。简单来说，第一次从arr[0]–arr[n-1]中选取最小值与arr[0]交换，第二次从arr[1]–arr[n-1]中选取最小值与arr[1]交换，…，第i次从arr[i-1]–arr[n-1]中选取最小值与arr[i-1]交换，第n-1次从arr[n-2]–arr[n-1]中选取最小值与arr[n-2]交换，总共通过n-1次，得到一个排序码从小到大排列的有序序列。

图解

代码实现

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;//假设最小值的下标
        int min = arr[i];//假设是最小值
        for (int j = i + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j];
                minIndex = j;
            }
        }
        if (minIndex != i) {//如果最小值的下标等于当前下标，则不交互
            arr[minIndex] = arr[i];
            arr[i] = min;
        }
    }
}

插入排序

原理

把n个待排序的元素看成为一个有序和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

图解

代码实现

public static void insertSort(int[] arr) {
    int insertVal = 0;
    int insertIndex = 0;
    for (int i = 1; i < arr.length; i++) {
        insertVal = arr[i];//待插入的数
        insertIndex = i - 1;//待插入数前一个数的位置
        while (insertIndex >= 0 && insertVal <arr[insertIndex]) {//待插入的数小于前面的数
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        if (insertIndex + 1 != i) {
            arr[insertIndex + 1] = insertVal;
        }
    }
}

希尔排序

原理

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

图解

代码实现

//交换法
public static void shellSort(int[] arr) {
    int temp = 0;
    int count = 0;
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {//步长gap
        for (int i = gap; i < arr.length; i++) {
            for (int j = i - gap; j >= 0; j-=gap) {
                if (arr[j] > arr[j + gap]) {
                    temp = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = temp;
                }
            }
        }
        System.out.println("希尔排序第" + (++count) + "轮=" + Arrays.toString(arr));
    }
}
//移位法
public static void shellSort2(int[] arr) {
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        //从第gap个元素开始逐个对其所在的组进行直接插入排序
        for (int i = gap; i < arr.length; i++) {
            int j = i;
            int temp = arr[j];
            if (arr[j] < arr[j - gap]) {
                while (j - gap >= 0 && temp < arr[j - gap]) {
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                arr[j] = temp;
            }
        }
    }
}

快速排序(QuickSort)

原理

快速排序是对冒泡排序的一种改进，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

图解

代码实现

public static void quickSort(int[] arr, int left, int right) {
    int l = left;//左下标
    int r = right;//右下标
    int pivot = arr[(left + right)/2];//中抽值
    int temp = 0;//临时变量，作为交换时使用
    while (l < r) {//while循环的目的是让比pivot值小放到左边，比pivot值大放到右边
        //在pivot的左边一直找，找到大于等于pivot值，才退出
        while (arr[l] < pivot) {
            l+=1;
        }
        //在pivot的右边一直找，找到小于等于pivot值，才退出
        while (arr[r] > pivot) {
            r-=1;
        }
        //如果l>=r说明pivot的左右两的值，已经按照左边全部是小于等于pivot值，右边全部是大于等于pivot值
        if (l >= r) {
            break;
        }
        //交换
        temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
        //如果交换完后，发现这个arr[r]==pivot值相等r--,前移
        if (arr[l] == pivot) {
            r-=1;
        }
        //如果交换完后，发现这个arr[r]==pivot值相等l++,后移
        if (arr[r] == pivot) {
            l+=1;
        }
    }
    //如果l==r,必须l++,r--,否则会出现栈溢出
    if (l == r) {
        l+=1;
        r-=1;
    }
    //向左递归
    if (left < r) {
        quickSort(arr, left, r);
    }
    //向右递归
    if (right > l) {
        quickSort(arr, l, right);
    }
}

归并排序(MergeSort)

原理

归并排序是利用归并的思想实现的排序算法，该算法采用经典的分治(divide-and-conquer)策略，分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之

图解

代码实现

public static void mergeSort(int[] arr, int left, int right, int[] temp) {
    if (left < right) {
        int mid = (left + right) / 2;//中间索引
        //向左递归进行分解
        mergeSort(arr, left, mid, temp);
        //向右递归进行分解
        mergeSort(arr, mid + 1, right, temp);
        //合并
        merge(arr, left, mid, right, temp);
    }
}

private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
    int i = left;//初始化i,左边有序序列的初始索引
    int j = mid + 1;//初始化j,右边有序序列的初始索引
    int t = 0;//指向temp数组的当前索引
    //先把左右两边(有序)的数据按照规则填充到temp数组，直到左右两边的有序序列，有一边处理完毕为止
    while (i <= mid && j <= right) {
        //如果左边的有序序列的当前元素小于等于右边有序序列的当前元素，即将左边的当前元素，填充到temp数组，然后t++,i++
        if (arr[i] <= arr[j]) {
            temp[t] = arr[i];
            t+=1;
            i+=1;
        } else {//反之，将右边有序序列的当前元素，填充到temp数组
            temp[t] = arr[j];
            t+=1;
            j+=1;
        }
    }
    //把有剩余数据的一边的数据依次全部填充到temp
    while (i <= mid) {//左边的有序序列还有剩余的元素，就全部填充到temp
        temp[t] = arr[i];
        t+=1;
        i+=1;
    }
    while (j <= right) {//右边的有序序列还有剩余的元素，就全部填充到temp
        temp[t] = arr[j];
        t+=1;
        j+=1;
    }
    //将temp数组的元素拷贝到arr,并不是每次都拷贝所有
    t = 0;
    int tempLeft = left;
    while (tempLeft <= right) {
        arr[tempLeft] = temp[t];
        t+=1;
        tempLeft+=1;
    }
}

基数排序(RadixSort)

基数排序属于“分配式排序”，又称“桶子法”，通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用

原理

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零，然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。

图解

代码实现

private static void radixSort(int[] arr) {
    //1.得到数组中最大的位数
    int max = arr[0];//假设第一个数就是最大数
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    int maxLength = (max + "").length();//最大数的位数
    //2.定义一个二维数组，表示10个桶，每个桶就是一个一维数组；包含10个一维数组，每个一维数组大小为arr.length
    int[][] bucket = new int[10][arr.length];
    //3.定义一个一维数组记录各个桶的每次放入的数据个数
    int[] bucketElementCounts = new int[10];
    for (int i = 0, n = 1; i < maxLength; i++, n*= 10) {
        for (int j = 0; j < arr.length; j++) {
            int digitOfElement = arr[j] / n % 10;//取出每个元素对应位的值
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        int index = 0;
        for (int k = 0; k < bucketElementCounts.length; k++) {
            if (bucketElementCounts[k] != 0) {
                for (int l = 0; l < bucketElementCounts[k]; l++) {
                    arr[index++] = bucket[k][l];
                }
            }
            bucketElementCounts[k] = 0;
        }
        System.out.println("第" + (i + 1) + "轮，对个位的排序处理arr=" + Arrays.toString(arr));
    }
}

堆排序

1.堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
2.堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆，注意：没有要求节点的左孩子和右孩子的值的大小关系。
3.每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆
4.一般升序采用大顶堆，降序采用小顶堆

原理

1.将待排序序列构造成一个大顶堆
2.此时，整个序列的最大值就是堆顶的根节点
3.将其与末尾元素进行交换，此时末尾就为最大值
4.然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列

图解

代码实现

private static void heapSort(int[] arr) {
    int temp = 0;
    //将无序序列构建成一个堆，根据升序或降序需求选择大顶堆或小顶堆
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        adjustHeap(arr, i, arr.length);
    }
    //将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端，重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序
    for (int i = arr.length - 1; i > 0; i--) {
        temp = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;
        adjustHeap(arr, 0, i);
    }
}
private static void adjustHeap(int[] arr, int i, int lenght) {
    int temp = arr[i];
    for (int k = i * 2 + 1; k < lenght; k = k * 2 + 1) {
        if (k + 1 < lenght && arr[k] < arr[k + 1]) {
            k++;
        }
        if (arr[k] > temp) {
            arr[i] = arr[k];
            i = k;
        } else {
            break;
        }
    }
    arr[i] = temp;
}

八种排序算法的比较

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面
时间复杂度：一个算法执行所耗费的时间
空间复杂度：运行完一个程序所需内存的大小
n：数据规模
k：“桶”的个数
In-place：不占用额外内存
Out-place：占用额外内存