程序员,你应该知道的基础排序算法

冒泡排序(Bubble Sort)

原理

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置,重复 n 次,就完成了 n 个数据的排序工作。

图解

图片来源网络,侵权即删

性能

  • 时间复杂度:O(n2)
  • 最好时间复杂度:O(n)
  • 最差时间复杂度:O(n2)
  • 平均时间复杂度:O(n2)
  • 空间复杂度:O(1)

代码

    public static void bubbleSort(int[] a, int n) {
        if (n <= 1) return;

        for (int i = 0; i < n; ++i) {
            // 如果没有数据交换,则提前退出,提前退出冒泡循环的标志位
            boolean flag = false;

            for (int j = 0; j < n - i - 1; ++j) {
                if (a[j] > a[j+1]) { // 交换
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                    flag = true;  // 表示有数据交换
                }
            }
            if (!flag) break;  // 没有数据交换,提前退出
        }
    }

插入排序(Insertion Sort)

原理

插入排序就像我们玩棋牌一样,每次摸的牌我们都会插入到合适的位置,保证我们的牌是有序的,在这个过程中我们有一个比大小的操作,插入排序没我们手动方便,插入排序除了比大小之外还需要元素移动。例如:需要将一个数据 a 插入到已排序区间时,需要拿 a 与已排序区间的元素依次比较大小,找到合适的插入位置。找到插入点之后,我们还需要将插入点之后的元素顺序往后移动一位,这样才能腾出位置给元素 a 插入。

图解

图片来源网络,侵权即删

性能

  • 时间复杂度:O(n2)
  • 最好时间复杂度:O(n)
  • 最差时间复杂度:O(n2)
  • 平均时间复杂度:O(n2)
  • 空间复杂度:O(1)

    代码

    // 插入排序,a 表示数组,n 表示数组大小
    public static void insertionSort(int[] a, int n) {
        if (n <= 1) return;

        for (int i = 1; i < n; ++i) {
            int value = a[i];
            int j = i - 1;
            // 查找插入的位置
            for (; j >= 0; --j) {
                if (a[j] > value) {
                    a[j + 1] = a[j];  // 数据移动
                } else {
                    break;
                }
            }
            a[j + 1] = value; // 插入数据
        }
    }

选择排序(Selection Sort)

原理

选择排序的思想很简单,从数组的下标i=0开始,在i+1后面找出最小的一个元素与i对应的值比大小,如果i+1的值小于i的值,则将这两个数进行交换,然后i++后面重这种操作,直到整个数组排好序。

图解

图片来源网络,侵权即删

性能

  • 时间复杂度:O(n2)
  • 最好时间复杂度:O(n2)
  • 最差时间复杂度:O(n2)
  • 平均时间复杂度:O(n2)
  • 空间复杂度:O(1)

代码

public static void sort(int arr[],int n){
    for( int i = 0;i < n ; i++ ){
        int min = i;//最小元素的下标
        for(int j = i + 1;j < n; j++ ){
            if(arr[j] < arr[min]){
                min = j;//找最小值
            }
        }
        //交换位置
        int temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
}

归并排序(Merge Sort)

原理

归并排序采用的是分而治之的思想,我们将要排序的数组从中间分成两半,分别对前后两个数组进行排序,然后将接口合并,这样整个数据就有序了。

归并排序一般我们采用递归的方式,将数组进行拆分到不可分为止,然后对不可拆分的数组进行排序,左右两半数组分别从第一个开始逐一比较大小,放入到新的临时数组中,当左右两半的值一样时,将左边的值先放入到数组中,最后判断左右两边是否有剩余,将剩余的数组加入到临时数组中,经过上面的操作后,整个数组都有序了,最后需要将临时数组的值拷贝回原数组中,整个归并排序就完成了。

图解

我们以数组40, 2, 11, 5, 15, 6, 90, 10来演示归并排序的过程

性能

  • 时间复杂度:O(nlogn)
  • 最好时间复杂度:O(nlogn)
  • 最差时间复杂度:O(nlogn)
  • 平均时间复杂度:O(nlogn)
  • 空间复杂度:O(n)

代码

    /**
     * 递归 将数组分成两半,分别对前后两部分排序
     *
     * @param nums     数组
     * @param leftPtr  左半边开始下标
     * @param rightPtr 右半边结束下标
     */
    public static void merge_sort(int[] nums, int leftPtr, int rightPtr) {
        if (leftPtr >= rightPtr) return;
        // 将数组分成两半
        int mid = leftPtr + (rightPtr - leftPtr) / 2;

        // 左半边排序
        merge_sort(nums, leftPtr, mid);

        // 右半边排序
        merge_sort(nums, mid + 1, rightPtr);

        merge(nums, leftPtr, mid + 1, rightPtr);
    }

    /**
     * 将前后两半排好序的数组进行合并
     *
     * @param nums
     * @param leftPtr    左半边开始下标值
     * @param rightPtr   右半边开始下标值
     * @param rightBound 左半边结束值
     */
    public static void merge(int[] nums, int leftPtr, int rightPtr, int rightBound) {
        // 新开辟临时排序数组
        int[] sortNums = new int[rightBound - leftPtr + 1];
        // 求出中间值
        int mid = rightPtr - 1;
        // 前半部分数组起始下标
        int i = leftPtr;
        // 后半部分起始下标
        int j = rightPtr;

        // 临时排序数组的起始下标
        int k = 0;

        // 左右两边分别逐一比较,将小的存入到临时数组
        while (i <= mid && j <= rightBound) {
            sortNums[k++] = nums[i] <= nums[j] ? nums[i++] : nums[j++];
        }
        // 判断左半边时候有剩下
        while (i <= mid) sortNums[k++] = nums[i++];
        // 判断右半边时候有剩下
        while (j <= rightBound) sortNums[k++] = nums[j++];

        // 将数组拷贝回nums
        for (int m = 0; m < sortNums.length; m++) nums[leftPtr + m] = sortNums[m];
    }

快速排序(Quick Sort)

原理

快速排序也称做快排,快排跟归并排序一样也是利分治思想。快排分为单轴快排和双轴快排,因为双轴排序效率比单抽排序效率高,所以这篇主要讲的是双轴排序。快速排序每次从数组中随机选择一个元素作为pivot(一般情况下,选择数组的最后一个元素),然后从数组的第一个元素和分区值前一个元素开始进行查找,从第一个元素开始查找比分区值大的第一个数A,从分区值前面的一个数往前开始查找,找到第一个比分区值小的数B,将AB交换位置,直到左边开始查找的下标大于右边开始查找的下标停止查找,然后将分区值与第一个大于分区值的数交换位置,这样分区值左边的数就全部小于分区值,右边的数全部大于分区值。继续遍历左右两边的数组,直到整个数组排好序。

图解

我们以数组40, 2, 11, 5, 15, 6, 90, 10来演示快速排序的过程

选择数组最右边的值作为分区值,即黄颜色的数组10,建立两个下标索引,一个指向数组的第一个元素left,一个指向分区值的前一位数组的元素right,即图中用红色箭头标出来的地方。从左边开始找出第一个比分区值大的元素,从右边找出第一个比分区值小的元素,将这两个元素进行交换并且将坐标往后移,即图中的第二步和第三步,按照上面的规则继续查找,直到left > right 为止。将分区值与left所指的元素进行交换,这样分区值左边的数都是比分区值小的,右边的数都是被分区值大的。按照上面的规则继续遍历左右两边的数组,最后整个数组就排好序了。

性能

  • 时间复杂度:O(nlogn)
  • 最好时间复杂度:O(nlogn)
  • 最差时间复杂度:O(n2)
  • 平均时间复杂度:O(nlogn)
  • 空间复杂度:O(logn)

代码

// 递归
    public static void sort(int[] nums, int leftBound, int rightBound) {
        if (leftBound >= rightBound) return;
        // 分区值的下标位置
        int mid = partition(nums, leftBound, rightBound);
        // 左分区排序
        sort(nums, leftBound, mid - 1);
        // 右分区排序
        sort(nums, mid, rightBound);
    }

    // 分区
    public static int partition(int[] nums, int leftBound, int rightBound) {

        // 分区点的值
        int piovt = nums[rightBound];

        // 左边下标
        int left = leftBound;
        //右边起始下标
        int right = rightBound - 1;

        while (left <= right) {
            // 找到第一个大于分区值的
            while (left <= right && nums[left] <= piovt) left++;

            // 找到第一个小于分区值的
            while (left <= right && nums[right] > piovt) right--;

            // 将左右两边的值进行交换
            if (left < right) swap(nums, left, right);
        }
        // 将left的值与分区值交换位置
        swap(nums, left, rightBound);

        return left;
    }

    /**
     * 数据交换
     *
     * @param nums
     * @param i
     * @param k
     */
    public static void swap(int[] nums, int i, int k) {
        int temp = nums[i];
        nums[i] = nums[k];
        nums[k] = temp;

    }

桶排序(Bucket sort)

原理

桶排序,顾名思义,会用到“桶”,核心思想是将要排序的数据按照范围分到几个桶里,每个桶里的数据再单独进行排序。桶内排完序之后,再把每个桶里的数据按照顺序依次取出,组成的序列就是有序的了。

图解

我们以数组90,85,63,34,42,12,10来演示桶排序的过程

性能

  • 时间复杂度:O(n)
  • 最好时间复杂度:O(n)
  • 最差时间复杂度:O(nlogn)
  • 平均时间复杂度:O(n)
  • 空间复杂度:O(n)

    代码


    public static void sort(int[] nums) {
        //最大值
        int maxValue = nums[0];
        // 最小值
        int minValue = nums[0];

        int length = nums.length;

        /**
         * 求出最大最小值
         */
        for (int i = 1; i < length; i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
            } else if (nums[i] < minValue) {
                minValue = nums[i];
            }
        }
        //最大值和最小值的差,
        int diff = maxValue - minValue;

        //初始化桶列表
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            bucketList.add(new ArrayList<Integer>());
        }

        //桶之间的数值间距
        float section = (float) diff / (float) (length - 1);

        //数据入桶
        for (int i = 0; i < length; i++) {
            //当前数除以区间得出存放桶的位置 减1后得出桶的下标
            int num = (int) (nums[i] / section) - 1;
            if (num < 0) {
                num = 0;
            }
            bucketList.get(num).add(nums[i]);
        }

        //桶内排序
        for (int i = 0; i < bucketList.size(); i++) {

            //jdk内置的集合排序框架
            Collections.sort(bucketList.get(i));
        }

        //写入原数组
        int index = 0;
        for (ArrayList<Integer> arrayList : bucketList) {
            for (int value : arrayList) {
                nums[index] = value;
                index++;
            }
        }
    }

计数排序(Counting sort)

原理

计数排序其实是桶排序的一种特殊情况,当要排序的 n 个数据,所处的范围并不大的时候,比如最大值是 k,我们就可以把数据划分成 k 个桶。每个桶内的数据值都是相同的,省掉了桶内排序的时间。比如腾讯面试题,不用数据交换,查询出你的成绩排名?考生的满分是 750 分,最小是 0 分,这个数据的范围很小,所以我们可以分成 750 个桶,对应分数从 0 分到 750 分。根据考生的成绩,我们将这 50 万考生划分到这 750 个桶里。桶内的数据都是分数相同的考生,所以并不需要再进行排序。我们只需要依次扫描每个桶,将桶内的考生依次输出到一个数组中,就实现了 50 万考生的排序。

图解

我们以数组5,8,9,7,8,4,5,6,9,3,0,2,1来演示计数排序的过程

性能

  • 时间复杂度:O(n)
  • 最好时间复杂度:O(n)
  • 最差时间复杂度:O(n)
  • 平均时间复杂度:O(n)
  • 空间复杂度:O(n)

代码

    /**
     * 计数排序
     *
     * @param nums       待排序数组
     * @param rangeCount 数组范围个数
     * @param min        最小的个数
     * @return
     */
    public static int[] countingSort(int[] nums, int rangeCount, int min) {
        int[] result = new int[nums.length];

        // 定义计数桶
        int[] count = new int[rangeCount + min];

        // 将数据添加到桶里
        for (int i = 0; i < nums.length; i++) {
            count[nums[i]]++;
        }

        // 遍历桶 将数据写入到返回数组中
        for (int i = min, j = 0; i < count.length; i++) {
            while (count[i]-- > 0) result[j++] = i;
        }
        return result;
    }

基数排序(Radix sort)

原理

基数排序也是桶排序的一种,基数排序对要排序的数据是有要求的,需要可以分割出独立的“位”来比较,而且位之间有递进的关系,如果 a 数据的高位比 b 数据大,那剩下的低位就不用比较了,除此之外,每一位的数据范围不能太大,要可以用线性排序算法来排序。例如假设我们有 10 万个手机号码,需要按照从小到大的顺序对电话号码排序,前面的快排、桶排序、计数排序都可以进行快速的排序,但是内存有限,不允许你做这样的操作,这是就可以使用基数排序来解决这个问题。

图解

我们以数组2154,5896,356,201,698,412来演示基数排序的过程

性能

  • 时间复杂度:O(n*k)
  • 最好时间复杂度:O(n*k)
  • 最差时间复杂度:O(n*k)
  • 平均时间复杂度:O(n*k)
  • 空间复杂度:O(n+k)

代码

public static void radixSort(int[] nums){

        // 记录数组的大小
        int length = nums.length;

        //最大值
        int numMax = nums[0];
        for(int i = 0;i < length;i++){
            if(nums[i] > numMax){
                numMax = nums[i];
            }
        }
        //当前排序位置
        int location = 1;

        //桶列表 一个桶中会有多个不同的元素
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();

        //初始化一个空桶
        for(int i = 0; i < 10; i++){
            bucketList.add(new ArrayList<Integer>());
        }

        while(true)
        {
            //求出每位数的最小值
            int min = (int)Math.pow(10,(location - 1));
            // 判断最大值是否小于每位数的最小值,小于就结束
            if(numMax < min){
                break;
            }
            //遍历数据,将数据写入桶
            for(int i = 0; i < length; i++)
            {
                //计算余数 放入相应的桶
                int number = ((nums[i] / min) % 10);
                bucketList.get(number).add(nums[i]);
            }
            //将数从桶中取回,重新组成数组
            int k = 0;
            for (int i=0;i<10;i++){
                int size = bucketList.get(i).size();
                for(int j = 0;j < size;j ++){
                    nums[k++] = bucketList.get(i).get(j);
                }
                // 将桶清空,用于下一次排序
                bucketList.get(i).clear();
            }
            // 位数加一
            location++;
        }
    }

以上就是编程中的基本排序算法,基本排序算法,在很多组件内部使用,如果对基础排序了解的话,对你阅读源码还是有些帮助的,非常感觉你看到这里,希望这篇文章对你有所帮助。

如果您发现文中错误,还请多多指教。欢迎关注个人公众号,一起交流学习。

个人公众号

原文地址:https://www.cnblogs.com/jamaler/p/11397275.html

时间: 2024-11-05 14:48:18

程序员,你应该知道的基础排序算法的相关文章

Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法

Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看 8种排序之间的关系: 1.直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2]

Java 常用排序算法/程序员必须掌握的 8大排序算法

Java 常用排序算法/程序员必须掌握的 8大排序算法 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看 8种排序之间的关系: 1.直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排 好顺序的,现在要把第n 个数插到前

程序员必须掌握的8大排序算法(Java版)

程序员必须掌握的8大排序算法(Java版) 提交 我的评论 加载中 已评论 程序员必须掌握的8大排序算法(Java版) 2015-07-28 极客学院 极客学院 极客学院 微信号 jikexueyuan00 功能介绍 极客学院官方帐号,最新课程.活动发布.欢迎大家反馈问题哟^_^ 本文由网络资料整理而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空

Java常用排序算法/程序员必须掌握的8大排序算法

转载自http://blog.csdn.net/qy1387/article/details/7752973 分类: 1)插入排序(直接插入排序.希尔排序)2)交换排序(冒泡排序.快速排序)3)选择排序(直接选择排序.堆排序)4)归并排序5)分配排序(基数排序)所需辅助空间最多:归并排序所需辅助空间最少:堆排序平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序.    [java] view plain copy print? // 排序原始数据 private static final

Java程序员必须掌握的8大排序算法

8种排序之间的关系: 1, 直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排 好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数 也是排好顺序的.如此反复循环,直到全部排好顺序. (2)实例 (3)用java实现 packagecom.njue; public class insertSort { publicinsertSort(){ inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99

[转]Java 常用排序算法/程序员必须掌握的 8大排序算法

本文转自:http://www.cnblogs.com/qqzy168/archive/2013/08/03/3219201.html 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看 8种排序之间的关系: 1.

Java程序员必知的8大排序算法

8种排序之间的关系 直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排 好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数 也是排好顺序的.如此反复循环,直到全部排好顺序. (2)实例 (3)用java实现 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 public class insertSort {     public insertSort(){         int a[]={49,38,65,97,76,13,27

程序员找工作必备 PHP 基础面试题 (四)

程序员找工作必备 PHP 基础面试题? 程序员找工作必备 PHP 基础面试题(二)? 程序员找工作必备 PHP 基础面试题 (三) 一.在 HTTP1.0 中,状态吗 500 的含义的是什么?如果返回 “找不到文件” 的提示,则可用 header(函数),其语句为? 500 Internal Server Error 服务器遇到了意料不到的情况,不能完成客户的请求 Header(“ HTTP/1.0 404 NOT FOUND”); 二.数组函数 arsort()的作用是什么?语句 err_re

黑马程序员——Java I/O流基础知识点(File类)

File工具 File类就是用俩将文件或者文件夹封装对象,弥补流对象的不足--流只能操作数据,不能操作文件夹的 封装的是路径!!! 构造方法演示 1.可以将已有的未出现的文件或者文件夹封装成对象. File f1=new File("c:\\abc\\a.txt"): File f2=new File("d:\\abc","ab.txt"打印,会打印路径.:目录分隔符,为了更好地跨平台File. File类常见功能 1,创建 createNewF

好程序员web前端分享HTML基础篇

好程序员web前端分享HTML基础篇,最近遇到很多新手,都会问,如果要学web前端开发,需要学什么?难不难学啊?多久能入门之类的问题?那么今天好程序员就先来给大家分享一下web前端学习路线:HTML基础 学习目标 1.本专业介绍.HTML相关概念,HTML发展历史 2.WEB标准,W3C/WHATWG/ECMA相关概念 3.相关软件的应用以及站点的创建 4.HTML基本结构和HTML语法 5.HTML常用标记 一.本专业介绍.HTML相关概念,HTML发展历史 本专业介绍 移动前端/WEB前端