图解算法：八大排序算法

已于 2022-10-03 09:49:41 修改
阅读量2.3k 收藏 21
点赞数 5
分类专栏： 数据结构与算法 文章标签： 排序算法 算法 数据结构
于 2022-03-15 10:54:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_53947466/article/details/123496521
版权

目录

一、冒泡排序（bubbleSort）

1.1、介绍

  • 比较相邻的元素，如果第一个比第二个大，就交换他们两个
  • 对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对，这步做完后，最后的元素应该会是最大的数
  • 每次过后，需要排序的元素就越来越少，对剩下需要排序的元素重复上面的步骤，直到没有任何一对数字需要比较
  • 时间复杂度为 O(n2)

1.2、演示

原始数组：5 4 3 2 1

  • 4 3 2 1 5
  • 3 2 1 4 5
  • 2 1 3 4 5
  • 1 2 3 4 5

在这里插入图片描述

1、外层排序只需要进行 数组长度-1 次（最后一次已经默认确定最小值在头部，不需要再排序）

2、内层排序

  • 排序次数先 -1，因为 n 个元素只需要进行 n-1 次替换
  • 每一躺排序的次数在逐渐减少 -i（因为每一次排序后都会确定一个数在末尾）

1.3、实现

public static void bubbleSort(int[] arr) {
    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]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第" + (i + 1) + "次排序后的数组：" + Arrays.toString(arr));
    }
}

优化写法：如果发现某趟排序中没有发生一次变化，可以提前结束冒泡排序

public static void bubbleSort(int[] arr) {
	boolean flag = 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]) {
            	flag = true;  // 发生交换
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
		
		System.out.println("第" + (i + 1) + "次排序后的数组：" + Arrays.toString(arr));	
		
		if(!flag){
			break;		  // 跳出循环
		}else {
			flag = false; // 重置flag
		}
		
    }
}

二、选择排序（Selection Sort）

2.1、介绍

  • 从待排序的元素中选出最小的元素，存放在起始位置，固定住该最小元素
  • 同理取出未固定的元素中的最小元素，存放在起始位置，固定
  • 以此类推，直到全部待排序的数据元素的个数为零。

2.2、演示

原始序列：9 2 5 3 7

  • 2 9 5 3 7
  • 2 3 5 9 7
  • 2 3 5 9 7
  • 2 3 5 7 9

在这里插入图片描述
外层循环只需要执行（数组.length-1）次（最后一次已经默认确定最大值在末尾，不需要再排序）

2.3、实现

public static void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        // 找出最小值下标
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
        System.out.println("第" + (i + 1) + "次排序后的数组：" + Arrays.toString(arr));
    }
}

三、插入排序（Insertion Sort）

3.1、介绍

一般也被称为直接插入排序

  • 将一个待排序的数组分成两部分，前一部分代表是有序序列，后一部分代表未排序序列
  • 将第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列
  • 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置
  • 如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面，直到未排序序列全部扫描完毕为止。

3.2、演示

3.3、实现

public static void insertionSort(int[] arr) {
	// 待插入的数为从下标为1开始，因为先把下标为0的固定住了
    for (int i = 1; i < arr.length; i++) {
    	// 循环与前面的有序序列的每个值进行比较，若有序序列的下标小于0则中断循环
        for (int j = i - 1; j >= 0; j -= 1) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

四、希尔排序（Shell Sort）

4.1、介绍

一般也被称为缩小增量排序，希尔排序是对插入排序的一种改进

  • 按下标的一定增量进行分组，对每组使用插入排序算法排序
  • 随着增量逐渐减少，每组包含的元素越来越多，当增量减至 1 时，恰被分成一组，算法便终止

4.2、演示

在这里插入图片描述

4.3、实现

public static void shellSort(int[] arr) {
    for (int step = arr.length / 2; step > 0; step /= 2) {
        //核心代码就是插入排序，把所有的一替换成step
        for (int i = step; i < arr.length; i++) {
            for (int j = i - step; j >= 0; j -= step) {
                if (arr[j] > arr[j + step]) {
                    int temp = arr[j];
                    arr[j] = arr[j + step];
                    arr[j + step] = temp;
                }
            }
        }
    }
}

五、快速排序

5.1、介绍

快速排序（Quick Sort）是对冒泡排序算法的一种改进

  • 首先设定一个基准值，通过该基准值将数组分成左右两部分，将小于或等于基准值的数据放到数组的左边，将大于或等于基准值的数据放到数组的右边
  • 此时左边部分中各元素都小于或等于基准值，而右边部分中各元素都大于或等于基准值，然后左边和右边的数据又可以分别独立排序。
  • 对于左侧的数组数据，又可以再取一个基准值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值，右侧的数组数据也可以做类似处理
  • 重复上述过程，可以看出，这是一个递归定义
  • 通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

在这里插入图片描述

5.2、演示

在这里插入图片描述

5.3、实现

public static void quickSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}

public static void quickSort(int[] arr, int left, int right) {
    int l = left;                       //左下标
    int r = right;                      //右下标
    int p = arr[(left + right) / 2];    //基准值
    //交换基准值左右大小值
    while (l < r) {
        //在基准值的左边一直找，直到找到大于等于基准值后才退出，最坏查找到自身
        while (arr[l] < p) { l++; }
        //在基准值的右边一直找，直到找到小于等于基准值后才退出，最坏查找到自身
        while (arr[r] > p) { r--; }
        //如果l>=r则说明：基准值左侧的值都小于基准值右侧的值
        if (l >= r) {
            break;
        }
        //将基准值左侧找到的小值与基准值右侧找到的大值进行交换
        int temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
        //如果交换完后，发现这个arr[r]等于基准值，l++向前移
        if (arr[r] == p) { l++; }
        //如果交换完后，发现这个arr[l]等于基准值，r--向前移
        if (arr[l] == p) { r--; }
    }
    //这一步来防止堆栈溢出
    if (l == r) {
        l++;
        r--;
    }
    //向左递归进行快速排序
    if (left < r) {
        quickSort(arr, left, r);
    }
    //向右递归进行快速排序
    if (right > l) {
        quickSort(arr, l, right);
    }
}

六、归并排序

6.1、介绍

归并排序用到了分而治之的思想，其难点是治

  • 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
  • 设定两个指针，最初位置分别为两个已经排序序列的起始位置
  • 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
  • 重复上一步 直到某一指针达到序列尾
  • 将另一序列剩下的所有元素直接复制到合并序列尾

6.2、演示

在这里插入图片描述
动图演示
在这里插入图片描述

6.3、实现

// 分+合 默认值
public static void mergeSort(int[] arr) {
    mergeSort(arr, 0, arr.length - 1, new int[arr.length]);
}

// 分+合
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
    if (left < right) {
        int mid = (left + right) / 2;

        // 向左分解
        mergeSort(arr, left, mid, temp);
        // 向右分解
        mergeSort(arr, mid + 1, right, temp);

        // 合并
        merge(arr, left, mid, right, temp);
    }
}

// 治
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
    int i = left;    // 左边序列初始索引
    int j = mid + 1; // 右边序列初始索引
    int t = 0;       // temp数组的当前索引

    // 1）先把左右序列按顺序填充到temp数组，直到左右序列有一方处理完毕
    while (i <= mid && j <= right) {
        // 如果左序列的值小于右序列则进行存放并将左序列指针右移
        if (arr[i] < arr[j]) {
            temp[t] = arr[i];
            t++;
            i++;
        } else { // 如果右序列的值小于等于左序列则进行存放并将右序列指针右移
            temp[t] = arr[j];
            t++;
            j++;
        }
    }

    // 2）把有剩余数据的一边序列全部填充到temp
    // 如果左边还有剩余
    while (i <= mid) {
        temp[t] = arr[i];
        t++;
        i++;
    }
    // 如果右边还有剩余
    while (j <= right) {
        temp[t] = arr[j];
        t++;
        j++;
    }

    // 3）将temp数组的元素拷贝回arr
    t = 0;
    int tempLeft = left;
    while (tempLeft <= right) {
        arr[tempLeft] = temp[t];
        t++;
        tempLeft++;
    }

}

七、基数排序

7.1、介绍

  • 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零
  • 定义 0-9 十个桶进行存放排序数据
  • 从最低位开始，依次进行一次排序
  • 从最低位排序一直到最高位（个位->十位->百位->…->最高位）排序完成以后, 数列就变成一个有序序列

在这里插入图片描述

7.2、演示

在这里插入图片描述

下面分步骤演示：

起始数组及9个桶
在这里插入图片描述

1.1、按照个位，放到对应的桶中
在这里插入图片描述

1.2、依次取出，同一个桶中有多个元素的，先放入的先取出
在这里插入图片描述

2.1、再按照十位，放到对应的桶中，个位数前面补0

在这里插入图片描述
2.2、再依次取出桶中元素
在这里插入图片描述

3.1、再按照百位，放到对应的桶中，个位数和十位数前面补0
在这里插入图片描述
3.2、再依次取出桶中元素
在这里插入图片描述

7.3、实现

1、基础代码实现

public static void radixSort(int[] arr) {
    // 定义桶，为防止栈溢出将每个一维数组定义为arr.length，缺点占用空间较多，因为待排序数列有可能为同样位数 1 3 5 7
    int[][] bucket = new int[10][arr.length];

    // 记录每个桶中的元素个数 (bucketElementCounts[0]代表0号桶，默认为0个元素)
    int[] bucketElementCounts = new int[10];

    /**
     * 个位数
     */
    for (int i = 0; i < arr.length; i++) {
        int digitOfElement = arr[i] % 10;
        // 放入对应桶中（如放入0号桶并记录）
        bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
        // 记录桶内数据 +1
        bucketElementCounts[digitOfElement]++;
    }

    // 定义从0开始的下标为原数组复原做准备
    int index = 0;
    // 遍历桶并将数据放回原数组
    for (int i = 0; i < bucketElementCounts.length; i++) {
        if (bucketElementCounts[i] != 0) {
            for (int j = 0; j < bucketElementCounts[i]; j++) {
                arr[index++] = bucket[i][j];
            }
        }
        // 重置为0为下一轮做准备
        bucketElementCounts[i] = 0;
    }

    System.out.println("个位数结束" + Arrays.toString(arr));

    /**
     * 十位数
     */
    for (int i = 0; i < arr.length; i++) {
        int digitOfElement = arr[i] / 10 % 10;
        // 放入对应桶中（如放入0号桶并记录）
        bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
        // 记录桶内数据 +1
        bucketElementCounts[digitOfElement]++;
    }

    // 按照桶的顺序
    index = 0;
    // 遍历桶并将数据放回原数组
    for (int i = 0; i < bucketElementCounts.length; i++) {
        if (bucketElementCounts[i] != 0) {
            for (int j = 0; j < bucketElementCounts[i]; j++) {
                arr[index++] = bucket[i][j];
            }
        }
        // 重置为0为下一轮做准备
        bucketElementCounts[i] = 0;
    }

    System.out.println("十位数结束" + Arrays.toString(arr));


    /**
     * 百位数
     */
    for (int i = 0; i < arr.length; i++) {
        int digitOfElement = arr[i] / 100 % 10;
        // 放入对应桶中（如放入0号桶并记录）
        bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
        // 记录桶内数据 +1
        bucketElementCounts[digitOfElement]++;
    }

    // 按照桶的顺序
    index = 0;
    // 遍历桶并将数据放回原数组
    for (int i = 0; i < bucketElementCounts.length; i++) {
        if (bucketElementCounts[i] != 0) {
            for (int j = 0; j < bucketElementCounts[i]; j++) {
                arr[index++] = bucket[i][j];
            }
        }
        // 重置为0为下一轮做准备
        bucketElementCounts[i] = 0;
    }

    System.out.println("百位数结束" + Arrays.toString(arr));

}

2、代码优化：获取数组最大位数决定需要进行多少次排序

public static void radixSort(int[] arr) {
    // 得到数组最大位数
    int max = arr[0];
    for (int val : arr) {
        if (val > max) {
            max = val;
        }
    }
    int maxLength = (max + "").length();
    
    // 定义桶
    int[][] bucket = new int[10][arr.length];
    // 定义缺省桶元素个数
    int[] bucketElementCounts = new int[10];
    
    for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
        // 入桶
        for (int j = 0; j < arr.length; j++) {
            int digitOfElement = arr[j] / n % 10;
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        
        // 出桶
        int index = 0;
        for (int a = 0; a < bucketElementCounts.length; a++) {
            if (bucketElementCounts[a] != 0) {
                for (int b = 0; b < bucketElementCounts[a]; b++) {
                    arr[index++] = bucket[a][b];
                }
            }
            // 重置为0为下一轮做准备
            bucketElementCounts[a] = 0;
        }

        System.out.println(n + "位数结束" + Arrays.toString(arr));
    }
}

八、堆排序

8.1、介绍

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为 O(nlogn)，它也是不稳定排序

堆是具有以下性质的完全二叉树：

  • 每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆
  • 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
  • 没有要求结点的左孩子的值和右孩子的值的大小关系
  • 一般升序排序采用大顶堆，降序排列使用小顶堆

大顶堆特点：arr[i] >= arr[2*i+1] && arr[i] >= arr[2*i+2]，升序排序采用大顶堆

在这里插入图片描述
小顶堆特点：arr[i] <= arr[2*i+1] && arr[i] <= arr[2*i+2]，降序排序采用小顶堆
在这里插入图片描述

8.2、演示

排序思路

  • 将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
  • 找出最大值放在堆顶位置后将堆顶元素依次固定到数组末端（这里用大顶堆得到升序序列）
  • 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序

详细步骤演示

步骤一：将给定无序序列构造成一个大顶堆，一般升序采用大顶堆，降序采用小顶堆

1、给定原始数组并进行初始化
在这里插入图片描述
2、从最后一个非叶子结点6开始，该节点左右节点中9最大，进行换位，从左至右，从下至上进行调整
在这里插入图片描述
3、找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换
在这里插入图片描述
4、这时交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6
在这里插入图片描述
此时，我们就将一个无序序列构造成了一个大顶堆

步骤二：将堆顶元素与末尾元素进行交换，使末尾元素最大，然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素，如此重复以上操作

1、将堆顶元素9和末尾元素4进行交换
在这里插入图片描述
2、重新调整结构，使其继续满足堆定义
在这里插入图片描述
3、再将堆顶元素8与末尾元素5进行交换，得到第二大元素8
在这里插入图片描述
4、后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序
在这里插入图片描述

动态图展示
在这里插入图片描述

8.3、实现

public static void heapSort(int[] arr) {
    // 步骤一:将序列构造为大顶堆
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        adjustHeap(arr, i, arr.length);
    }

    // 步骤二:将堆顶元素与末尾元素进行交换，使得末尾元素最大
    for (int j = arr.length - 1; j > 0; j--) {
        int temp = arr[j];
        arr[j] = arr[0];
        arr[0] = temp;
        adjustHeap(arr, 0, j);
    }
}

/**
 * @param index  非叶子节点索引
 * @param length 对多少个元素进行调整，逐渐减少
 */
public static void adjustHeap(int[] arr, int index, int length) {
    int temp = arr[index];

    // 调整左子节点
    for (int k = index * 2 + 1; k < length; k = k * 2 + 1) {
        if (arr[k] < arr[k + 1] && k + 1 < length) { // 如果左值小于右值
            k++; // k指向右子节点
        }
        // 如果该子节点大于父节点
        if (arr[k] > temp) {
            arr[index] = arr[k]; // 把该子节点的值赋给父节点
            // 将父节点的下标赋值给被替换的子节点 为子节点替换父节点旧值做准备
            // 如果还有子节点，这里也是为初始循环赋值父节点下标
            index = k;
        } else {
            break;
        }
    }

    // 当for循环结束，已经将i为父节点的树的最大值放在最顶
    // 将父节点初始值赋值给被替换的子节点
    arr[index] = temp;
}
Laptoy
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据结构 】八大排序（插入，希尔，选择，堆，归并，快排，冒泡，计数）
呋喃吖的博客
07-17 6520
一 排序的基本概念 排序啊，一个很有趣的话题，排序就是使得数据能够成为一种有序的操作。（并不严谨，可是这样理解就够了。）准确的定义，朋友们可以看看数据结构的书哈，我就不复制粘贴了哈。 为什么要有排序这个概念呢，它有啥用呢？ 答：其实排序的主要目的就是为了提高查找效率，就比如说，二分查找算法，前提必须有有序的数据才可以使用，极大提高了查找效率。，在我的理解，我的理解上啊，其实从广义上讲：把数据结构分为四大块，线性表，非线性表，排序，查找。前面的三大板块都是为了查找做准备的，都是为了提高查找效率，怎么说呢
八大经典排序算法
weixin_43164548的博客
03-01 1万+
详细讲解了经典的排序算法的思路和实现过程
八大排序算法——（万字图文详解）
Forward♞的博客
06-28 2164
本篇博客将对“直接插入排序”、“希尔排序”、“直接选择排序”、“堆排序”、“冒泡排序”、“快速排序”、“归并排序”、“计数排序”进行详细的解析（算法逻辑、具体实现过程、时间复杂度、稳定性），并附以图片帮助大家更好地理解算法逻辑以及实现每个排序的参考代码。
数据结构——八大排序（全）
weixin_48560325的博客
02-09 9766
排序的基本概念和分类 排序算法的稳定性 概念：假设 Ki=Kj(1<=i<=n,1<=j<<n,i!=j),且在排序前的序列中Ri领先于Rj（即i<j）。如果排序后Ri仍领先于Rj，则说明所用的排序算法是稳定的；反之，若可能使得排序后的序列中Ri领先于Rj，则称所用的排序算法是不稳定的。 内排序和外排序 根据在排序过程中待排序的记录是否全部被放置在内存中，排序分为：内排序和外排序。 内排序实在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序记
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
Xpccccc的博客
10-13 4556
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
八大排序算法
热门推荐
黄规速博客:学如逆水行舟，不进则退
07-23 103万+
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。 快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分...
图解程序员必须掌握的Java常用8大排序算法
09-03
本文主要讲解了Java程序员必须掌握的8种常见排序算法，通过图文结合的方式帮助读者理解并实现这些排序方法。这些排序算法包括插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序以及LST基数排序。...
八大排序算法整理
10-19
自己整理的八大排序算法的实现以及其各自的特点，希望能帮助需要的人
最快的排序算法 图解八大排序算法——我见过的最详细的讲解（转），排序算法数据结构
04-07
八大排序算法的比较可以从时间复杂度、空间复杂度和稳定性三个方面进行比较，其中选择排序和冒泡排序的时间复杂度都是 O(n^2)，空间复杂度都是 O(1)；插入排序的时间复杂度是 O(n^2)，空间复杂度是 O(1)；归并排序和...
算法图解笔记以及代码文件.zip
08-09
这些排序算法各有优劣，如冒泡排序和插入排序适用于小规模数据，而快速排序和归并排序在大规模数据处理上表现优秀。 2. **查找算法**：如线性查找、二分查找和哈希查找。二分查找在有序数组中查找效率高，而哈希...
排序算法动态图解！一看就懂
03-30
收集了几乎全部的排序算法的动图图解，更有堆排序算法逐帧截图！绝对让你一看就懂！
各动态图示排序算法（冒泡、快排、堆排）
06-10
Qt 书写c++各图示排序，其中包含冒泡排序、快速排序、堆排序算法
12种排序算法详解（寒小阳博客转出PDF版）
07-16
12种排序算法详解（寒小阳博客转出PDF版）............................
算法图解11
08-08
分治算法是一种重要的算法设计策略，它将大问题分解为相互独立且与原问题形式相同的子问题，递归地解决这些子问题，然后合并子问题的解以得到原问题的解。例如，快速排序和归并排序都是分治思想的应用。分治与递归...
八大排序
qq_38352283的博客
05-26 244
八大排序算法  概述  排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。  我们这里说说八大排序就是内部排序。 当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。 快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布
数据结构初阶：八大排序
yourfriendyo的博客
02-07 3044
排序是一种非常重要的基础算法，在校招和工作中都非常的实用，它在日常生活中无处不在。本章将介绍八大基本排序。所谓排序，就是将一串序列按照某种递增递减的关系，使该序列成为一个有序的序列。常见并实用的排序有如下八种。
【数据结构与算法 11，互联网大厂面试必问的JVM底层原理
m0_61440508的博客
09-06 722
int min = arr[minIndex]; for(int j = 1 + i;j<arr.length;j++){ if(min > arr[j]){ min = arr[j]; minIndex = j; } } arr[minIndex] = arr[i]; arr[i] = min; } } 4、速度测试 选择排序：120000数...
八大排序 - (详解)
向未来❀去探索 的博客
04-04 2490
八大排序
图解排序算法及实现——快速排序 （Quick Sort）
张渊猛的博客
09-04 2万+
接下来让我们看看大名鼎鼎的快速排序，光名字就觉得牛哄哄。 那么具体怎么讲待 1.单路排序 图例如下 比照了示意图，很容易写出代码： def QuickSort(arr): n = len(arr) _quickSort(arr,0,n-1) def _quickSort(arr,l,r): if l &amp;amp;amp;amp;amp;amp;amp;gt;= r: re...
c++归并排序算法图解
最新发布
10-17
好的，下面是 c++ 归并排序算法的图解： ![归并排序算法图解](https://img-blog.csdn.net/20180509103249609?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXRpYy5wbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/q/80) 归并排序是一种分治思想的排序算法，它将待排序的序列分成两个子序列，对每个子序列进行递归排序，然后将两个已排序的子序列合并成一个有序的序列。具体实现时，可以使用递归或迭代的方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Laptoy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值