【五】排序算法

最新推荐文章于 2021-04-06 16:40:14 发布
最新推荐文章于 2021-04-06 16:40:14 发布
阅读量848 收藏 1
点赞数
分类专栏： JavaSE 文章标签： 排序算法 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41449756/article/details/106936625
版权

一、排序算法的概念

1、排序算法的介绍

2、排序的分类

3、算法的时间复杂度

3.1、度量一个程序(算法)执行时间的两种方法

3.2、时间频度

3.3、时间复杂度

3.4、常见的时间复杂度

3.5、平均时间复杂度和最坏时间复杂度

二、排序算法

1、冒泡排序

1.1、基本介绍

1.2、演示冒泡过程的例子(图解)

1.3、冒泡排序应用实例

2、选择排序

2.1、选择排序思想

2.2、选择排序思路分析图

2.3、选择排序应用实例

3、插入排序

3.1、插入排序法思想

3.2、插入排序思路图

3.3、插入排序法应用实例

4、希尔排序

4.1、简单插入排序存在的问题

4.2、希尔排序法介绍

4.3、希尔排序法基本思想

4.4、希尔排序法的示意图

4.5、希尔排序法应用实例

5、快速排序

5.1、快速排序法介绍

5.2、快速排序法示意图

5.3、快速排序法应用实例

一、排序算法的概念

1、排序算法的介绍

排序也称排序算法(Sort Algorithm),排序是将一组数据,依指定的顺序进行排列的过程。

2、排序的分类

3、算法的时间复杂度

3.1、度量一个程序(算法)执行时间的两种方法

1) 事后统计的方法
        这种方法可行, 但是有两个问题:一是(程序可运行)要想对设计的算法的运行性能进行评测,需要实际运行该程序;二是(计算机状况一样)所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式,要在同一台计算机的相同状态下运行,才能比较那个算法速度更快。

2) 事前估算的方法
       通过分析某个算法的时间复杂度来判断哪个算法更优.

3.2、时间频度

  • 基本介绍

时间频度:一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为 T(n)。

  • 举例说明-基本案例

  • 举例说明-忽略常数项

  • 举例说明-忽略低次项

  • 举例说明-忽略低次项

  • 举例说明-忽略系数

3.3、时间复杂度

1) 一般情况下,算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数,用 T(n)表示,若有某个辅助函数 f(n),使得当 n 趋近于无穷大时,T(n) / f(n) 的极限值为不等于零的常数,则称 f(n)是 T(n)的同数量级函数。记作 T(n)=O( f(n) ),称O( f(n) ) 为算法的渐进时间复杂度,简称时间复杂度。

2) T(n) 不同,但时间复杂度可能相同。 如:T(n)=n2+7n+6 与 T(n)=3n2+2n+2 它们的 T(n) 不同,但时间复杂
度相同,都为 O(n2)。

3) 计算时间复杂度的方法:

  • 用常数 1 代替运行时间中的所有加法常数 T(n)=n2+7n+6=> T(n)=n2+7n+1
  • 修改后的运行次数函数中,只保留最高阶项 T(n)=n2+7n+1 => T(n) = n2
  • 去除最高阶项的系数 T(n) = n2 => T(n) = n2 => O(n2)

3.4、常见的时间复杂度

  • 常数阶 O(1)
  • 对数阶 O(log2n)
  • 线性阶 O(n)
  • 线性对数阶 O(nlog2n)
  • 平方阶 O(n^2)
  • 立方阶 O(n^3)
  • k 次方阶 O(n^k)
  • 指数阶 O(2^n)

说明：

  • 常见的算法时间复杂度由小到大依次为:Ο(1)<Ο(log2n)<Ο(n)<Ο(nlog2n)<Ο(n^2)<Ο(n^3)< Ο(n^k) <Ο(2^n) ,随着问题规模 n 的不断增大,上述时间复杂度不断增大,算法的执行效率越低
  • 从图中可见,我们应该尽可能避免使用指数阶的算法
  • 常数阶 O(1)

  • 对数阶 O(log2n)

  • 线性阶 O(n)

  • 线性对数阶 O(nlogN)

  • 平方阶 O(n2)

3.5、平均时间复杂度和最坏时间复杂度

1) 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下,该算法的运行时间。

2) 最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。这样做的原因是:最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限,这就保证了算法的运行时间不会比最坏情况更长。

3) 平均时间复杂度和最坏时间复杂度是否一致,和算法有关(如图:)

二、排序算法

1、冒泡排序

1.1、基本介绍

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

优化:

因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。

1.2、演示冒泡过程的例子(图解)

小结上面的图解过程:

(1) 一共进行 数组的大小-1 次 大的循环
(2)每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中,没有发生一次交换, 可以提前结束冒泡排序。这个就是优化

1.3、冒泡排序应用实例

我们举一个具体的案例来说明冒泡法。我们将五个无序的数:3, 9, -1, 10, -2 使用冒泡排序法将其排成一个从小到大的有序数列。

代码实现：

package com.narwal.sort;

import java.util.Arrays;

/**
 * 第i趟就把第i大的数放到倒数第i个位置
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {-1, 2, -3, 5, 0};
//        int[] arr = {-3, 2, -1};
        bubbleSort(arr);
    }

    private static void bubbleSort(int[] arr) {
        int temp;
        boolean change = 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]) {
                    change = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (change) {
                change = false;  // 重置flag，进行下次判断
            } else {
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
        /*
        int temp;
        // 第一趟;把最大的放在最后面
        for(int i=0; i<arr.length-1; i++){
            if(arr[i]>arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
        // 第二趟；把第二大的放在倒数第二个位置
        for(int i=0; i<arr.length-1-1; i++){
            temp = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }*/
    }
}

2、选择排序

2.1、选择排序思想

选择排序(select sorting)也是一种简单的排序方法。它的基本思想是:第一次从 arr[0]~arr[n-1]中选取最小值,与 arr[0]交换,第二次从 arr[1]~arr[n-1]中选取最小值,与 arr[1]交换,第三次从 arr[2]~arr[n-1]中选取最小值,与 arr[2]交换,...,第 i 次从 arr[i-1]~arr[n-1]中选取最小值,与 arr[i-1]交换,..., 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值,与 arr[n-2]交换,总共通过 n-1 次,得到一个按排序码从小到大排列的有序序列。

2.2、选择排序思路分析图

2.3、选择排序应用实例

有一群牛 , 颜值分别是 101, 34, 119, 1 请使用选择排序从低到高进行排序 [101, 34, 119, 1]

代码实现：

package com.narwal.sort;

import java.util.Arrays;

/**
 * 第i轮就将倒数第i大的数据放在第i个位置
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        selectSort(arr);
    }

    private 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]) {
                    minIndex = j;
                    min = arr[j];
                }
            }
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
        System.out.println(Arrays.toString(arr));
        /*
        // 使用逐步推到的方式
        // 原始的数组：101, 34, 119, 1
        // 第一轮排序：1, 34, 119, 101

        // 第一轮:将最小的放在最前面
        int minIndex = 0;
        int min = arr[0]; // 假定第一个就是最小值
        for (int j = 1; j < arr.length; j++) {
            if (min > arr[j]) {  // 说明假定的最小值，并不是最小值
                min = arr[j]; // 重置min
                minIndex = j; // 重置minIndex

            }
        }
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println(Arrays.toString(arr));
        // 第二轮：将倒数第二小的放在第二个位置
        minIndex = 1;
        min = arr[1];
        for (int j = 1 + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                minIndex = j;
                min = arr[j];
            }
        }
        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println(Arrays.toString(arr));
        */
    }
}

3、插入排序

3.1、插入排序法思想

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

3.2、插入排序思路图

3.3、插入排序法应用实例

有一群小牛, 考试成绩分别是 101, 34, 119, 1请从小到大排序

代码实现：

package com.narwal.sort;

import java.util.Arrays;

/**
 * 插入排序(Insertion Sorting)的基本思想是:把 n 个待排序的元素看成为一个有序表和一个无序表,开始时有
 * 序表中只包含一个元素,无序表中包含有 n-1 个元素,排序过程中每次从无序表中取出第一个元素,把它的排
 * 序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。
 */
public class InsertSort {  // 后面无需的插入到前面有序的
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        insertSort(arr);
    }

    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];
            int insertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];// insertVal已经保存了待插入的值；
                insertIndex--;
            }
            //当退出 while 循环时,说明插入的位置找到, insertIndex + 1
            arr[insertIndex + 1] = insertVal;
            System.out.println(Arrays.toString(arr));
        }
        /*// 第一轮{101, 34, 119, 1} => {34, 101, 119, 1}
        // 定义待插入的数
        int insertVal = arr[1];
        int insertIndex = 0; // 即arr[1]前面的位置，就是要插入的位置

        // 给insertVal找到插入的位置
        // 说明
        // 1、insertIndex>=0 保证在给insertVal找插入位置不越界
        // 2、insertVal<arr[insertIndex]前面还有数比它小；要插入到刚好比它大的数前面
        // 3、就需要将arr[insertIndex]后移
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];// insertVal已经保存了待插入的值；
            insertIndex--;
        }
        //当退出 while 循环时,说明插入的位置找到, insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("第 1 轮插入");
        System.out.println(Arrays.toString(arr));

        // 第二轮
        insertVal = arr[2];
        insertIndex = 1; // 即arr[1]前面的位置，就是要插入的位置
        while (insertIndex >= 0 && insertVal < arr[insertIndex]){
            arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
            insertIndex--;
        }
        arr[insertIndex + 1] = insertVal;
        System.out.println("第 2 轮插入");
        System.out.println(Arrays.toString(arr));

        // 第二轮
        insertVal = arr[3];
        insertIndex = 2; // 即arr[1]前面的位置，就是要插入的位置
        while (insertIndex >= 0 && insertVal < arr[insertIndex]){
            arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
            insertIndex--;
        }
        arr[insertIndex + 1] = insertVal;
        System.out.println("第 3 轮插入");
        System.out.println(Arrays.toString(arr));

    }*/
    }

}

4、希尔排序

4.1、简单插入排序存在的问题

我们看简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是:
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时,后移的次数明显增多,对效率有影响.

4.2、希尔排序法介绍

希尔排序是希尔(Donald Shell)于 1959 年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序。

4.3、希尔排序法基本思想

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

4.4、希尔排序法的示意图

4.5、希尔排序法应用实例

有一群小牛, 考试成绩分别是 {8,9,1,7,2,3,5,4,6,0} 请从小到大排序. 

代码实现：

package com.narwal.sort;

import java.util.Arrays;

/**
 * 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,
 * 每组包含的关键词越来越多,当增量减至 1 时,整个文件恰被分成一组,算法便终止(组内排序)
 */
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
//        shellSort(arr);
        shellSort2(arr);
    }

    // 希尔排序时, 对有序序列在插入时采用交换法,
    public static void shellSort(int[] arr) {
        int temp;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                // 遍历各组中所有的元素（共5组，每组有2个元素），步长为5
                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("希尔排序后=" + Arrays.toString(arr));
        /*// 希尔排序的第一轮排序
        // 因为第一轮排序是将10个数据分成了5组
        for (int i = 5; i < arr.length; i++) {
            // 遍历各组中所有的元素（共5组，每组有2个元素），步长为5
            for (int j = i - 5; j >= 0; j -= 5) {
                // 如果当前元素大于加上步长后的那个元素，说明可交换
                if (arr[j] > arr[j + 5]) {
                    temp = arr[j];
                    arr[j] = arr[j + 5];
                    arr[j + 5] = temp;
                }
            }
        }
        System.out.println("希尔排序 1 轮后=" + Arrays.toString(arr));
        // 第二轮
        // 因为第二轮是将10个数据分成了5/2=2组
        for (int i = 2; i < arr.length; i++) {
            for (int j = i - 2; j >= 0; j -= 2) {
                if (arr[j] > arr[j + 2]) {
                    temp = arr[j];
                    arr[j] = arr[j + 2];
                    arr[j + 2] = temp;
                }
            }
        }
        System.out.println("希尔排序 2 轮后=" + Arrays.toString(arr));
        // 第二轮
        // 因为第二轮是将10个数据分成了2/2=1组
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0; j -= 1) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("希尔排序 3 轮后=" + Arrays.toString(arr));*/
    }
    // 采用位移法
    public static void shellSort2(int[] arr) {

        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                while (j - gap >= 0 && temp < arr[j - gap]) {
                    arr[j] = arr[j - gap];  // 后移
                    j -= gap;
                }
                arr[j] = temp;
            }
        }
        System.out.println("希尔排序后=" + Arrays.toString(arr));
    }
}

5、快速排序

5.1、快速排序法介绍

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

5.2、快速排序法示意图

5.3、快速排序法应用实例

要求: 对 [-9,78,0,23,-567,70] 进行从小到大的排序,要求使用快速排序法。

代码实现

package com.narwal.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {-9, 78, 0, 23, 0, 70, -1, 900, 4561};
        quickSort(arr, 0, 8);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) {
        int l = left; //左下标
        int r = right; //右下标
        //pivot 中轴值
        int pivot = arr[(left + right) / 2];
        int temp; //临时变量,作为交换时使用
        //while 循环的目的是让比 pivot 值小放到左边
        //比 pivot 值大放到右边
        while (l < r) {
            //在 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[l] == 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);
        }
    }

}

 

努力的程序猿@
关注
专栏目录
（排序算法五）快速排序
像向日葵一样～～
07-18 179
基本思想： 快速排序(Quicksort)是对冒泡排序的一种改进。基本思想是:通过一趟排序将要排序的数据分割成独立的两 部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排 序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 时间复杂度&&空间复杂度&&稳定性 时间复杂度：O(n log n) 空间复杂度 ：O(log n) 稳定性：不稳定 图文分析： 原始数组：arr=[2,10,8,3,6,4,1]; 代码实现：
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
排序算法（五）——快速排序
不吃_花椒的博客
04-03 233
基本思想 快速排序也是基于分治算法得。步骤如下： （1）选择一个基准元素，通常选择第一个元素或者最后一个元素； （2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大； （3）此时基准元素在其排好序后的正确位置； （4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。 上图中，演示的是第一轮快速排序的过程，首先...
5.图解排序算法(五)之快速排序——三数取中法
qq_41731051的博客
03-27 392
作者： dreamcatcher-cx 出处： http://www.cnblogs.com/chengxiao/ 本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在页面明显位置给出原文链接。 图解排序算法(五)之快速排序——三数取中法 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据...
算法练习：排列组合之组合和
憧憬，思考，奋斗，飞翔
07-01 1800
问题描述 给出一组不同的正整数序列和一个目标值，求出所有可能的组合，使得组合里所有元素和为目标值。要求： 1）每个组合里的元素按照升序排列。 2）输出组合里不含有重复的组合。 3）输入序列中的整数可以多次使用。   举例： 输入{2，3，4，7}，目标值为7 输出{7}，{2，2，3}，{3，4}   问题分析 为了让输出元素按升序排列，可对输入序列进行排序。同这里我们使用递
排序算法之－－快速排序
热门推荐
ehxe Asp.Net&PHP
09-10 1万+
快速排序  分而治之方法还可以用于实现另一种完全不同的排序方法，这种排序法称为快速排序（quick sort）。在这种方法中， n 个元素被分成三段（组）：左段l e f t，右段r i g h t和中段m i d d l e。中段仅包含一个元素。左段中各元素都小于等于中段元素，右段中各元素都大于等于中段元素。因此l e f t和r i g h t中的元素可以独立排序，并且不必对l e f t和r
最快的排序算法 计算机最快的算法-史上14个最快速算法：孩子的计算能力爆表！大脑堪比计算机！...，排序算法数据结构
04-07
在计算机科学领域中，排序算法是一种基本的算法，它可以将数据按照一定的顺序排列，以便更好地存储、检索和处理数据。排序算法的速度和效率对程序的性能有着至关重要的影响。 1.冒泡排序算法 冒泡排序算法是一种...
数据结构课程设计五——排序算法综合分析.doc
06-03
数据结构课程设计五——排序算法综合分析 该资源是一个数据结构课程设计的五个部分，主要讲解排序算法的综合分析。该资源涵盖了多种排序算法，包括直接插入排序、希尔排序、快速排序、冒泡排序、堆排序和归并法排序...
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
五中基础排序算法实现细节
小熊不哭站起来撸
08-09 262
由于时间仓促，本文先展示实现代码，后续抽空进行思路的补充。 class Solution { public: /** * @param A: an integer array * @return: nothing */ void sortIntegers(vector&amp;lt;int&amp;gt; &amp;amp;A) { // wri...
排序算法 基数排序
liuliwei09的博客
04-06 137
C# 排序算法 快速排序 使用环境 vs2017 .net core 2.1 控制台程序 实现方式：快速排序是一种高效排序。它包含了“分而治之”以及“标兵”的思想。从数组中挑选一个数（一般为第一个数据）作为“标兵”，使比它小的放在它的左侧，比它大的放在它的右侧。 以【65】为标兵，定义变量保存，0位置为待处理位置，从right向前找直到找到比标兵小的，将其放入到待处理位置，left++，并设置当前为待处理位置，从left开始向后找比标兵大的放入待处理位置，right–，并设置当前为待处理位置。直到left&
排序算法之快速排序
吉大秦少游
10-04 502
快速排序 思想：快速排序的思想更为深刻，随意选取一个数（一般选择a[0]）作为基准值，然后在数组的左右两边设置两个哨兵，先让右边的哨兵进行巡逻，找到比基准值小的数；再让左边的哨兵进行巡逻，找到比基准值大的数，将两者交换。这里注意要先让右边的哨兵先出动。左右哨兵都找到后将找到的数据调换，就这样左右两个哨兵一直寻找一直调换，最后左右哨兵会相遇。由于总是右边的哨兵先寻找，所以最后找到的数字一定是比起始...
排序算法——快速排序
scwMason的博客
04-24 188
从图中我们可以看到：left指针，right指针，base参照数。其实思想是蛮简单的，就是通过第一遍的遍历（让left和right指针重合）来找到数组的切割点。第一步：首先我们从数组的left位置取出该数（20）作为基准（base）参照物。第二步：从数组的right位置向前找，一直找到比（base）小的数， ...
快速排序算法
F_V
12-10 459
在一本书上发现的一种改进版的快速排序算法，自己把它整理出来了。这里通过小数组的时候是用插入排序算法，大数组的时候使用快速排序算法进行对算法的优化。而且是用三数中值分割法取枢纽元保证这个两个数组分得的数学期望大小是相等的。（即取首，末，中三个点的中值作为枢纽元，且在比较过程中把另外两个排好序）用以保证算法效率的稳定性。　　我尝试用大量泛型随机整数(随机数范围大小等于数组的大小)，进行排序，其排序效率表
排序算法2---快速排序
Joyfulmath，一个快乐的程序员
03-23 532
2.quicksort算法思想：一组无序的数，取某一标杆（标杆为数列中的某个数），任何大于该数的值放在右边，任何小于该数的值放在左边，相等放那边都行。依次类推，每次最少可以排序一个数。从而在有限次后，该数组就可以排序好。快速排序是目前公认平均情况下算法复杂吧最优的。平均复杂度： T (n) = O(n )最差复杂度：Θ (n2 )伪代码：QUICKSORT(A, p, r) 1 if p
算法和排序的区别
YNO
09-24 804
一、前言 这一段时间对算法有了一个较为集中的学习，那么在学习的时候我们最应该的还是要对这些有一些认识，这样才能更好的前进 正文 1、什么是算法 算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范 的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解
快速排序
bianjie的博客
08-09 524
快速排序     通过一轮的排序将序列分割成独立的两部分，其中一部分序列的关键字（这里主要用值来表示）均比另一部分关键字小。继续对长度较短的序列进行同样的分割，最后到达整体有序。在排序过程中，由于已经分开的两部分的元素不需要进行比较，故减少了比较次数，降低了排序时间。 详细描述      首先在要排序的序列 a 中选取一个中轴值，而后将序列分成两个部分，其中左边的部分
算法学习（二）快速排序（上）
maozhuxigood
02-21 105
快速排序采用的思想是分而治之。 1）将一整个大的无序序数组，根据数组中的某一个值，将数组分成两部分，一部分比这个值小，一部分比这个值大。 2）然后再对这两部分各自进行同样的操作，而当每一部分都有序之后，整个数组也就有序了。 从第二点，我们很明显可以想到递归，那么关键点就是前面怎么分这个数组了。 比较经典的分法有两种，今天就先说最常用的一种，首先看下面这一个图： 1）首先要有两个指针，...
Python实现五大排序算法详解
"本文主要介绍了如何使用Python编程语言实现五种经典的排序算法，包括选择排序、冒泡排序、插入排序，以及两种效率更高的排序算法——快速排序和归并排序。这些排序算法是数据结构和算法学习中的基础内容，对于理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值