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

冒泡排序(Bubble Sort)

原理

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

图解

1776326-20190822223207781-1456630323.gif

图片来源网络,侵权即删

性能

  • 时间复杂度:O(n²)
  • 最好时间复杂度:O(n)
  • 最差时间复杂度:O(n²)
  • 平均时间复杂度:O(n²)
  • 空间复杂度: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 插入。

图解

1776326-20190822223214460-1999614774.gif

图片来源网络,侵权即删

性能

  • 时间复杂度:O(n²)
  • 最好时间复杂度:O(n)
  • 最差时间复杂度:O(n²)
  • 平均时间复杂度:O(n²)
  • 空间复杂度: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++后面重这种操作,直到整个数组排好序。

图解

1776326-20190822223223147-1084184948.gif

图片来源网络,侵权即删

性能

  • 时间复杂度:O(n²)
  • 最好时间复杂度:O(n²)
  • 最差时间复杂度:O(n²)
  • 平均时间复杂度:O(n²)
  • 空间复杂度: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来演示归并排序的过程
1776326-20190822223224302-2145316465.png

性能

  • 时间复杂度: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来演示快速排序的过程
1776326-20190822223225146-150643164.png
选择数组最右边的值作为分区值,即黄颜色的数组10,建立两个下标索引,一个指向数组的第一个元素left,一个指向分区值的前一位数组的元素right,即图中用红色箭头标出来的地方。从左边开始找出第一个比分区值大的元素,从右边找出第一个比分区值小的元素,将这两个元素进行交换并且将坐标往后移,即图中的第二步和第三步,按照上面的规则继续查找,直到left > right 为止。将分区值与left所指的元素进行交换,这样分区值左边的数都是比分区值小的,右边的数都是被分区值大的。按照上面的规则继续遍历左右两边的数组,最后整个数组就排好序了。

性能

  • 时间复杂度:O(nlogn)
  • 最好时间复杂度:O(nlogn)
  • 最差时间复杂度:O(n²)
  • 平均时间复杂度: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来演示桶排序的过程
1776326-20190822223225794-2016041895.png

性能

  • 时间复杂度: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来演示计数排序的过程

1776326-20190822223227155-451149197.png

性能

  • 时间复杂度: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来演示基数排序的过程
1776326-20190822223228555-1859244416.png

性能

  • 时间复杂度: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++;
        }
    }

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

最后

打个小广告,金九银十跳槽季,平头哥给大家整理了一份较全面的 Java 学习资料,欢迎扫码关注微信公众号:「平头哥的技术博文」领取,祝各位升职加薪。
1776326-20190822223232019-559291898.png

转载于:https://www.cnblogs.com/jamaler/p/11397275.html

已标记关键词 清除标记
表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
相关推荐
<span style="color:#404040;">1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。</span><br /><br /><span style="color:#404040;">2.网上数据结构和算法的课程不少,但存在两个问题:</span><br /><br /><span style="color:#404040;">1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了</span><br /><span style="color:#404040;">2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级 </span><br /><span style="color:#404040;">3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 </span><br /><span style="color:#404040;">4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴</span><br /><br /><span style="color:#404040;">3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。</span><br /><br /><span style="color:#404040;">教程内容:</span><br /><span style="color:#404040;">本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。</span><br /><br /><span style="color:#404040;">学习目标:</span><br /><span style="color:#404040;">通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。</span>
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页