几大排序算法总结

最新推荐文章于 2023-06-09 18:07:15 发布

qq_30137425

最新推荐文章于 2023-06-09 18:07:15 发布

阅读量428

点赞数

分类专栏：数据结构与算法文章标签：排序算法数据结构

本文链接：https://blog.youkuaiyun.com/qq_30137425/article/details/78536599

版权

数据结构与算法专栏收录该内容

2 篇文章

订阅专栏

参考：http://blog.youkuaiyun.com/liuxiao214/article/details/78526692

最近正在为校招做准备，故重新复习了一下数据结构，也复习了几大排序算法：冒泡排序、插入排序、选择排序、随机快排（后续还会更新剩下的几个排序算法）

1.冒泡排序

时间复杂度：O(N^2)
额外空间复杂度：O(1)
是否可实现稳定性：是

思路：在一个序列当中，从头到尾进行比较，若遇到前一个数比后一个数大的情况，就交换它们的位置，按此方法比较完后得到一个最大值，并且此最大值的位置也放到了最末尾，比较限界的末尾向前滑动。然后重复此过程。

public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int e = arr.length - 1; e > 0; e--) {
            for (int i = 0; i < e; i++) {
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                }
            }
        }
    }
    //两个变量交换值的方法
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

在这里介绍另一个交换两个变量值的方法

public static void swap(int a, int b) {
        a = a ^ b;  // a,b异或之后的结果为a,b之间不相同的部分
        b = a ^ b;  // 等价为 b = a ^ b ^ b = a
        a = a ^ b;  // 等价为 a = a ^ b ^ a = b
    }

表达式中的”^”称为异或运算符（满足交换律与结合律）
Tips:

我们可以把这些数据以二进制的形式表示，所以我们可以认为这里的a,b 是一串01的数值。
这种交换方法的使用前提是a,b为不同的变量，否则异或完结果只能为0。
可以把异或运算理解为无进位相加的运算，如

 0 1       1 1
 1 0       1 0
-----     -----
 1 1       0 1

2.插入排序

时间复杂度：O(N^2)
额外空间复杂度：O(1)
是否可实现稳定性：是

思路: 从未排好序的序列中取第一个数作为排好序的数列，每次从未排好序的数列中拿第一个p，将p往排好序的数列中插入，插入的过程是从已排好序的数列末尾向前依次比较，如果p比其小，则交换后继续往前比较，否则，不交换，此次排序结束。p向后移一个位置，重复此过程，直至p移动到最后一个位置

public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

3、选择排序

时间复杂度：O(N^2)
额外空间复杂度：O(1)
是否可实现稳定性：否

思路：从未排好序的数列中找到最小的值，将这个值放在已排好序的数列末尾，即与未排好序的首个值交换即可。找最小值只要依次比较即可。

public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

4.随机快速排序

时间复杂度：O(Nlog(N))
额外空间复杂度：O(log(N))
是否可实现稳定性：否

1、将数列划分为3个区域，小于区、等于区、大于区。

2、随机选取一个值，作为比较的基准值，将其与数列末尾交换。

3、设置变量 l （l == 0，即数列的起始位置），设置变量 r （r == 数列的长度 - 1，即基准值所在的位置），设置变量 less （less 指向小于区的最末尾，起始时 less == l - 1，因为此时小于区还不存在）
设置变量 more （more 指向大于区的头部，起始时 more == r，因为此时大于区也不存在）

4、取变量 l 对数列进行遍历，依次比较数列：

5、比基准值小的，放在小于区末尾，即 a[++less] 与 a[l] 交换，然后 l 指向下一个位置，即 l++

6、等于这个值的，小于区、大于区的所指位置都不需要移动，只将变量 l 指向下一个位置，即 l++

7、比这个值大的，放在大于区开头，即 a[–-more ]与 a[l] 交换，此时的 l 变量所指位置不改变。

8、当 l 指针到达大于区的位置时（即当l == more 时），比较结束。

9、基准值与大于区第一个值进行交换，这样，数列完成了小于区、等于区、大于区的分区。

10、此时的less+1是等于区首位置，more是等于区末位置。

11、然后递归在小于区、大于区进行上述过程即可。

public class QuickSort {

    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
            int[] p = partition(arr, l, r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr, p[1] + 1, r);
        }
    }

    public static int[] partition(int[] arr, int l, int r) {
        int less = l - 1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr, ++less, l++);
            } else if (arr[l] > arr[r]) {
                swap(arr, --more, l);
            } else {
                l++;
            }
        }
        swap(arr, more, r);
        return new int[] { less + 1, more };
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

5.归并排序

时间复杂度：O(Nlog(N))
额外空间复杂度：O(N)
是否可实现稳定性：是

思路：
1、将数列一直从中间分为左右部分，然后不断的将左部分从中间再划分为左右部分，直到不能划分位置（即只剩一个数为止），右部分同理。

2、按第1个步骤划分完之后，开辟一个辅助数组，其大小等于这两个合并数列的大小。设置两个变量 l 和 r 分别指向左右部分数组的首位置，将分割的所有左右部分进行合并，比较两个变量所指位置的大小，将比较小的数放入辅助数组当中（假设arr[l]小），将变量 l = l + 1 （即指向后一个位置），继续与 r 所指向的值比较。这样比较完后，如果两个数列中有个数列的数值有剩余，即其变量没有走到末尾，则将这个数列直接赋到辅助数组末尾即可。

3、然后将辅助数组中的值拷贝回原数组中刚才合并的那两个数列的位置上。

public class MergeSort {

    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }

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

    public static void merge(int[] arr, int l, int m, int r) {
        int[] help = new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = m + 1;
        while (p1 <= m && p2 <= r) {
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= m) {
            help[i++] = arr[p1++];
        }
        while (p2 <= r) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
    }
}

5.1 归并排序的两个应用

1、小和问题
如果每个数字左边比其小的数的相加之和称为小和。
求一个数列重所有的小和之和。
见博客。

2、逆序对问题
求一个数列中所有顺序为逆序的对数有几个。
逆序为大的值在小的值之前。
见博客。

6.堆排序

时间复杂度：O(Nlog(N))
额外空间复杂度：O(1)
是否可实现稳定性：否

思路：
1、将数列当成一个完全二叉树的结构，然后建立大根堆。建立大根堆的过程就是依次插入比较，设置变量i=0，当插入到i时，比较其是否比父节点（i-1）/2的值大，如果大，则交换两个节点，i节点更新为其父节点（i-1）/2，继续比较。直到该节点不再大于父节点，表示此时的大根堆已经完成。继续下一个节点的插入建立。

2、当建立好大根堆后，就可以开始排序。首先设置一个size值，用来表示未排序的范围。将堆顶与未排序的末尾交换，则此时未排序的末尾与已排好序的数列已经形成有序。交换后，堆顶不再是最大元素，需要进行调整使其保持大根堆。排序的过程就是堆顶与未排序的末尾不断交换，交换后调整使其仍为大根堆。

3、在交换后如何调整使其仍为大根堆，首先找到此时i的左节点，如果左节点未超过未排序范围size，则进入循环，如果右节点存在，则取左右节点中较大的值，与i位置的值比较，如果i值小就交换，否则与左节点比较，也是i值小就交换。交换后i更新为交换后的子节点，继续与其子节点比较，直到到达size。

public class HeapSort {

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        for (int i = arr.length - 1; i != 0; i--) {
            swap(arr, 0, i);
            heapify(arr, 0, i);
        }
    }

    public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

7、桶排序

时间复杂度：O(N)
额外空间复杂度：O(N)
是否可实现稳定性：是

桶排序不是基于比较的排序，其排序与数的个数无关，但对于数据的位数和范围有限制。

1、首先基于数据的范围创建相应大小的辅助数组help。即遍历找到数组的最大值，则辅助数组的大小即为最大值+1，且初始化为0。

2、辅助数组的每个位置i放置原数组中i的个数。

3、遍历辅助数组，根据位置i中的值，依次向原数组填入help[i]个i值。

public class BucketSort {

    public static void bucketSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr[i]);
        }
        int[] bucket = new int[max + 1];
        for (int i = 0; i < arr.length; i++) {
            bucket[arr[i]]++;
        }
        int i = 0;
        for (int j = 0; j < bucket.length; j++) {
            while (bucket[j]-- > 0) {
                arr[i++] = j;
            }
        }
    }
}