十大排序算法

最新推荐文章于 2024-08-16 17:15:42 发布
最新推荐文章于 2024-08-16 17:15:42 发布
阅读量179 收藏 1
点赞数
分类专栏： 算法 排序算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjc000/article/details/118769349
版权

​​​​​​​1 冒泡排序

1.1 算法描述

  • 比较相邻的元素。如果第二个比第一个小，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从最后一个到当前批次的开始下标i，这样在最上面元素会是最小的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 下标i+1，重复步骤1~3，直到排序完成

1.2 算法分析

1.2.1 时间复杂度

  • 平均：O(n2)
  • 最优：O(n) 已经排好序
  • 最坏：O(n2)

1.2.2 空间复杂度

    O(1)

1.2.3 稳定性

    稳定

1.3 算法实现

/**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    public void bubbleSort(int[] array) {
        boolean isChange = true;
        for (int i = 0; i < array.length - 1 && isChange == true; i++) {
            isChange = false;
            for (int j = array.length - 1; j > i; j--) {
                if (array[j] < array[j - 1]) {
                    isChange = true;
                    array[j] = array[j] + array[j - 1];
                    array[j - 1] = array[j] - array[j - 1];
                    array[j] = array[j] - array[j - 1];
                }
            }
        }
    }

2 选择排序

2.1 算法描述

  • 下标i从0开始到length-1结束，选择出最小的下标和i进行交换；
  • 下标i+1，重复步骤1，直到i=length-2

2.2 算法分析

2.2.1 时间复杂度

  • 平均：O(n2)
  • 最优：O(n2)
  • 最坏：O(n2)

2.2.2 空间复杂度

    O(1)

2.2.3 稳定性

    不稳定：[3,3,1]。第一个3会到第二个3后面

2.3 算法实现

    /**
     * 选择排序
     *
     * @param array
     * @return
     */
    public void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[minIndex] > array[j]) {
                    minIndex = j;
                }
            }
            int temp=array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }

3 插入排序

3.1 算法描述

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素A，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于元素A，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。

3.2.1 时间复杂度

  • 平均：O(n2)
  • 最优：O(n) 已经排好序
  • 最坏：O(n2)

3.2.2 空间复杂度

    O(1)

3.2.3 稳定性

    稳定

3.3 算法实现

    /**
     * 插入排序
     *
     * @param array
     * @return
     */
    public void insertionSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int j = i;
            int temp = array[i];
            for (; j > 0; j--) {
                if (temp >= array[j - 1]) {
                    break;
                }
                array[j] = array[j - 1];
            }
            array[j] = temp;
        }
    }

4 希尔排序

4.1 算法描述

  • 插入排序在小范围数组和已经排好序的数组效果最好，所以希尔排序使用了缩小增量排序
  • 选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列
  • 根据增量间隔来依次分组进行插入排序
  • 如gap=5，从第6个数n开始对{n-5,n-5-5,....1}进行插入排序，直到n=length

4.2.1 时间复杂度

  • 平均：O(n1.3)
  • 最优：O(n) 已经排好序，第一次间隔为1
  • 最坏：O(n2)

4.2.2 空间复杂度

    O(1)

4.2.3 稳定性

    不稳定：[1,3,3,1]。第一个3会到第二个3后面

4.3 算法实现

    /**
     * 希尔排序
     *
     * @param array
     * @return
     */
    public void shellSort(int[] array) {
        int length = array.length / 2;
        for (; length > 0; length = length / 2) {
            for (int i = length; i < array.length; i++) {
                int j = i;
                int temp = array[i];
                for (; j >= length; j -= length) {
                    if (temp >= array[j - length]) {
                        break;
                    }
                    array[j] = array[j - length];
                }
                array[j] = temp;
            }
        }
    }

5 归并排序

5.1 算法描述

  • 把长度为n的输入序列分成两个长度为n/2的子序列；
  • 对这两个子序列分别继续进行n/2拆分，直到长度为1；
  • 将两个排序好的子序列，从各自的最左端进行比较，把最小的放到新数组里面，等比较完成后再复制到原数组相应的位置。

5.2.1 时间复杂度

  • 平均：O(nlogn)
  • 最优：O(nlogn)
  • 最坏：O(nlogn)

5.2.2 空间复杂度

    O(n) 递归需要的栈帧，不用递归就是 O(1)

5.2.3 稳定性

    稳定

5.3 算法实现

    /**
     * 归并排序
     *
     * @param array
     * @return
     */
    public void mergeSort(int[] array) {
        mergeSort(0, array.length - 1, array, new int[array.length]);
    }

    public void mergeSort(int start, int end, int[] array, int[] temp) {
        if (end > start) {
            int mid = (start + end) / 2;
            mergeSort(start, mid, array, temp);
            mergeSort(mid + 1, end, array, temp);
            int left = start;
            int right = mid + 1;
            for (int i = start; i <= end; i++) {
                if (left > mid) {
                    temp[i] = array[right++];
                } else if (right > end) {
                    temp[i] = array[left++];
                } else if (array[left] <= array[right]) {
                    temp[i] = array[left++];
                } else {
                    temp[i] = array[right++];
                }
            }
            for (int i = start; i <= end; i++) {
                array[i] = temp[i];
            }
        }
    }

6 快速排序

6.1 算法描述

  • 从数列中挑出一个元素，称为 “基准”（pivot），通常是第一个；
  • 定义第一个为左下标，最后一个为右下标，从右下标开始向左移动依次与基准比较，找到第一个小于基数的下标，移动左下标找到第一个大于基数的下标，交换左右下标的数值，直到左下标等于又下标，此时这个基数就处于中间位置，即它的左边都小于等于它，右边都大于等于它；
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列分别进行1-2

6.2.1 时间复杂度

  • 平均：O(nlogn)
  • 最优：O(nlogn)
  • 最坏：O(n2)

6.2.2 空间复杂度

    O(nlogn) 递归需要的栈帧，不用递归就是 O(1)

6.2.3 稳定性

    不稳定：[3,3,1] 第一个3会到第二个3后面

6.3 算法实现

    /**
     * 快速排序
     *
     * @param array
     * @return
     */
    public void quickSort(int[] array) {
        quickSort(0, array.length - 1, array);
    }

    public void quickSort(int start, int end, int[] array) {
        if (start >= end) {
            return;
        }
        int left = start;
        int right = end;
        while (right > left) {
            while (right > left && array[right] >= array[start]) {
                right--;
            }
            while (right > left && array[left] <= array[start]) {
                left++;
            }
            if (right > left) {
                array[right] = array[right] + array[left];
                array[left] = array[right] - array[left];
                array[right] = array[right] - array[left];
                right--;
            }
        }
        if (start != left) {
            array[start] = array[start] + array[left];
            array[left] = array[start] - array[left];
            array[start] = array[start] - array[left];
        }
        quickSort(start, left - 1, array);
        quickSort(left + 1, end, array);
    }

7 堆排序

7.1 算法描述

  • 构建堆结构(以最大堆为例，最小堆反过来即可)，即a[i]>=a[2i+1]&&a[i]>=a[2i+2]
  • 按照二叉树定义，非叶子结点对应的叶子结点是2i+1和2i+2，同样节点n反过来求他的父节点，就可以用这个公式2i+1=n，如果求出来的是整数那么n就是左节点，如果是小数就是右节点；
  • 先从最后一位的下标通过上述公式反求出最后一个非叶子节点，然后和他的左右节点找出最大的换到那个节点数，如果进行了交换，那就对交换的节点进行堆调整，就是对这个节点的左右节点这接着进行此步骤，然后下标减1，直到到0
  • 然后把第一个也就是最大的和最后一个e进行交换，再将数组的0到e-1位继续进行2-4

7.2.1 时间复杂度

  • 平均：O(nlogn)
  • 最优：O(nlogn)
  • 最坏：O(nlogn)

7.2.2 空间复杂度

    O(1)

7.2.3 稳定性

    不稳定：[3,3,1] 第一个3会到第二个3后面

7.3 算法实现

    /**
     * 堆排序
     *
     * @param array
     * @return
     */
    public void heapSort(int[] array) {
        int length = array.length;
        for (int a = length - 1; a > 0; a--) {
            for (int i = (a - 1) / 2; i >= 0; i--) {
                heapSort(array, i, a);
            }
            swap(array, 0, a);
        }

    }

    public void heapSort(int[] array, int i, int end) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left > end) {
            return;
        }
        int maxIndex = right <= end && array[right] > array[left] ? right : left;
        if (array[i] < array[maxIndex]) {
            swap(array, i, maxIndex);
            heapSort(array, maxIndex, end);
        }
    }

    public void swap(int[] array, int i, int j) {
        array[i] = array[i] + array[j];
        array[j] = array[i] - array[j];
        array[i] = array[i] - array[j];
    }

8 计数排序

8.1 算法描述

  • 找出待排序的数组中最大和最小的元素的差值n，构建长度为n+1的数组C；
  • 数组中的值i，存入数组C的第i-最小值项，每出现一次，在C相应位置加1；
  • 遍历数组C，将不为0的下标作为值，放到原数组中，C的值是多少，就往原数组里面添加几次C的下标
  • 缺点是数据离散程度大的话，会浪费很大资源，而且不能比较小数，差值n不能大余int的最大值

8.2.1 时间复杂度

  • 平均：O(n+k)
  • 最优：O(n+k)
  • 最坏：O(n+k)

8.2.2 空间复杂度

    O(n+k)

8.2.3 稳定性

    稳定

8.3 算法实现

    /**
     * 计数排序
     *
     * @param array
     * @return
     */
    public void countingSort(int[] array) {
        int min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            } else if (array[i] > max) {
                max = array[i];
            }
        }
        int length = max - min + 1;
        int[] temp = new int[length];
        for (int item : array) {
            temp[item - min]++;
        }
        int index = 0;
        for (int i = 0; i < temp.length; i++) {
            while (temp[i] > 0) {
                temp[i]--;
                array[index++] = i + min;
            }
        }
    }

9 桶排序

9.1 算法描述

  • 设置一个定量的数组当作空桶，桶的范围是最大值和最小值的差值除桶数量；
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • 对每个不是空的桶进行插入排序；
  • 从不是空的桶里把排好序的数据拼接起来。

9.2.1 时间复杂度

  • 平均：O(n+k)
  • 最优：O(n) 都在一个桶内，并且已经排好序（插入排序的最优）
  • 最坏：O(n2) 都在一个桶内，并且已经是倒序（插入排序的最坏）

9.2.2 空间复杂度

    O(n+k)

9.2.3 稳定性

    稳定

9.3 算法实现

    /**
     * 桶排序
     *
     * @param array
     * @return
     */
    public void bucketSort(int[] array) {
        int bucketNum = 3;
        LinkedList[] linkedList = new LinkedList[bucketNum];
        int min = array[0], max = array[0];
        for (int item : array) {
            if (item < min) {
                min = item;
            } else if (item > max) {
                max = item;
            }
        }
        int bucketSize = (max - min) / bucketNum + 1;
        for (int item : array) {
            int bucketIndex = (item - min) / bucketSize;
            if (linkedList[bucketIndex] == null) {
                linkedList[bucketIndex] = new LinkedList();
            }
            LinkedList list = linkedList[bucketIndex];
            Iterator<Integer> iterator = list.iterator();
            int index = 0;
            while (iterator.hasNext()) {
                if (item < iterator.next()) {
                    break;
                }
                index++;
            }
            list.add(index, item);
        }
        int index = 0;
        for (int i = 0; i < linkedList.length; i++) {
            LinkedList<Integer> list = linkedList[i];
            if (list == null) {
                continue;
            }
            for (int item : list) {
                array[index++] = item;
            }
        }
    }

10 基数排序

10.1 算法描述

  • 设置0-19，20个数组（包括负数），
  • 先按照个位先排序，然后重新赋值到原数组；
  • 再按照高位排序，然后再重新赋值到原数组；
  • 依次类推，直到最高位。
  • 缺点：不支持小数

10.2.1 时间复杂度

  • 平均：O(n*k)
  • 最优：O(n*k)
  • 最坏：O(n*k) 

10.2.2 空间复杂度

    O(n+k)

10.2.3 稳定性

    稳定

10.3 算法实现

    /**
     * 基数排序
     *
     * @param array
     * @return
     */
    public void radixSort(int[] array) {
        int max = 0;
        for (int item : array) {
            item = item >= 0 ? item : -item;
            if (item > max) {
                max = item;
            }
        }

        LinkedList[] linkedList = new LinkedList[20];
        int down = 1;
        while (down <= max) {
            for (int item : array) {
                int remain = item / down % 10;
                int index = item >= 0 ? 10 + remain : 9 + remain;
                if (linkedList[index] == null) {
                    linkedList[index] = new LinkedList();
                }
                linkedList[index].add(item);
            }
            down *= 10;
            int index = 0;
            for (LinkedList linked : linkedList) {
                if (linked != null) {
                    Iterator<Integer> iterator = linked.iterator();
                    while (iterator.hasNext()) {
                        array[index++] = iterator.next();
                        iterator.remove();
                    }
                }
            }
        }
    }

@summer@
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
十大排序算法（一）
qq_44819554的博客
01-27 863
十大排序算法包括了递归、分治、二分、双指针等常见的解题方法，想要提高算法能力，排序算法必须得精通，能够自己独立写出程序。
常用十大排序算法
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
C语言实现十大排序算法.rar
11-21
本资源“C语言实现十大排序算法.rar”提供了一组C语言编写的排序算法实现，涵盖了常见的排序方法。接下来，我们将详细探讨这十大排序算法及其在C语言中的实现。 1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单的...
java十大排序算法实现
11-20
java十大排序算法实现 1. 冒泡排序（Bubble Sort） 2. 选择排序（Selection Sort） 3. 插入排序（Insertion Sort） 4. 快速排序（Quick Sort） 5. 归并排序（Merge Sort） 6. 堆排序（Heap Sort） 7. 计数排序...
php代码-十大排序算法
07-14
这个压缩包“php代码-十大排序算法”显然是一个包含PHP实现的十种常见排序算法的资源包。下面我们将详细讨论这十个排序算法以及它们在PHP中的应用。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序...
python十大排序算法
07-26
使用 python 实现十种最常见的排序算法：选择排序、冒泡排序、插入排序、归并排序、桶排序、计数排序、基数排序、（随机）快速排序、希尔排序和堆排序算法。 适用于数据结构与算法的学习过程中，也是面试过程中常被...
排序算法之折半插入排序
rd_w_csdn的博客
08-12 735
折半插入排序（Binary Insertion Sort）是插入排序的一种改进版本。它在插入每个元素时使用二分查找（Binary Search）来找到插入位置，从而减少比较次数。
排序算法之基数排序
rd_w_csdn的博客
08-12 993
基数排序（radix sort）的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。
希尔排序，详细解析（附图解）
最新发布
2301_80840905的博客
08-16 432
希尔排序是一种基于插入排序的算法，通过将原始数据分成若干个子序列，然后对子序列进行插入排序，逐渐减小子序列的间隔，最后对整个序列进行一次插入排序。
七大排序算法
dc爱傲雪和技术
08-13 2414
是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序的算法步骤如下：从第一个元素开始，该元素可以认为已经被排序；取出下一个元素，在已经排序的元素序列中从后向前扫描；如果该元素（已排序）大于新元素，将该元素移到下一位置；重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；将新元素插入到该位置后；重复步骤2~5。是一种基础的。
时间复杂度以及简单的排序算法
qq_63126439的博客
08-12 340
局部最小（i-1 > i < i+1）0 1 2 3 ……可以得到的表达式aN2+bN+c，常数项不要，低阶项不要，最高阶系数不要 时间复杂度：O（N^2）上面的代码跑完之后，值可以交换过来，（i和j在内存里是独立的内存）否则就会变为0。有N个数要进行比较，需要看N+N-1+N-2+N-3....+....1个。当两个算法的O（N）一样，只能通过实验来确定“常数项时间”需要比较N+N-1+N-2+N-3....+....1个。插入排序：O（N^2）按照最差的表现作为时间复杂度。冒泡排序：O（N^2）
CSP初赛知识点讲解（九）
CylMK的博客
08-13 829
的排序，有的效率是比较稳定的，即无论什 么情况都趋近于NlogN，比如归并排序，堆排，也有一 些排序时间复杂度是不稳定的，即在最坏情况下会趋近于。排序也分为稳定排序和不稳定排序，这个稳定与否不是 指排序效率的，而是指排序前后两个相等的数相对位置 一定不发生改变，则算法稳定。：不稳定排序，很容易想到，比如5 2 2 7 7， 第一个2和第二个7交换，第二个2和第一个7交换，位置变了。希尔排序：虽然是插入排序的升级版，但是他是不稳定的排序。：稳定排序，很明显，因为为递归，是一段一段的排，一定是稳定的。
数据结构-常见的七大排序
心动的那一刻，记忆便盛开了花
08-13 911
上节中我们学习了七大排序中的五种(这节我们将要学习快速排序(
排序算法之归并排序
rd_w_csdn的博客
08-12 1252
归并排序（Merge Sort）是一种基于分治法的有效排序算法。它将一个列表分成较小的子列表，对每个子列表进行排序，然后合并这些子列表以产生一个有序列表。
python 实现wiggle sort摆动排序算法
luthane的博客
08-13 395
Wiggle Sort摆动排序算法是一种可以将数组重新排列成摆动序列的排序算法。在摆动序列中，相邻元素的大小关系轮流改变，即元素a[i]和a[i+1]满足a[i] < a[i+1]，然后a[i+1] > a[i+2]，以此类推。以下是关于Wiggle Sort摆动排序算法的详细解释：算法原理算法的思路是通过交换数组中的元素，将其重新排列成摆动序列。具体来说，遍历数组，如果：i是奇数且a[i] > a[i+1]，或者i是偶数且a[i] < a[i+1]，则交换a[i]和a[i+1]。
十大排序算法详解与实现
本文档总结了经典的十大排序算法，包括冒泡排序、选择排序、插入排序、壳排序、归并排序、快速排序、堆排序、拓扑排序、锦标赛排序和基数排序，并提供了冒泡排序和选择排序的代码示例。此外，还提到了二分法和二叉树...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值