【数据结构-排序】3.图解选择排序两种实现(简单选择排序/堆排序)

最新推荐文章于 2026-01-23 23:21:39 发布
原创 最新推荐文章于 2026-01-23 23:21:39 发布 · 784 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #排序算法 #简单选择排序 #堆排序
本文详细介绍了简单选择排序和堆排序两种经典排序算法的工作原理、时间与空间复杂度，并提供了具体的实现代码及运行示例。

简单选择排序(选择排序)

排序思想

  1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
  2. 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  3. 以此类推，直到所有元素均排序完毕。

下面举个示例：

第一轮排序，i = 0，j = 1，min = 23，tmp = 23（tmp是用来记录当前需要调整位置的值），pos = 0（记录比min小的元素位置）。遍历，当 j=7 时，min = 18，pos=7。然后将 nums[i] = nums[pos]，j++，pos = i++

第二轮排序，i = 1，j = 2，min = 76，tmp = 76，pos = 1。遍历，当 j = 2 时，min = 34（黄标），pos = 2；继续遍历，当 j = 7 时，min = 23，pos = 7。然后将 nums[i] = nums[pos]，j++，pos = i++

第三轮排序，i = 2，j = 3 ，min = 34（黄标），tmp = 34（黄标），pos = 2。遍历，发现没有比 34（黄标）更小的元素了。然后将 j++，pos = i++

第四轮排序，i = 3，j = 4，min = 34（绿标），tmp = 34（绿标），pos = 3。遍历，发现没有比 34（绿标）更小的元素了，j++，pos = i++

第五轮排序，i = 4，j = 5，min = 90，tmp = 90，pos = 4；遍历，当 j = 5 时，min = 89 ，pos = 5 ；继续遍历，当 j = 6 时，min = 56，pos = 6；然后将 nums[i] = nums[pos]，j++，pos = i++

第六轮排序，i = 5，j = 6，min = 89，tmp = 89，pos = 5；遍历，当 j = 7 时，min = 76，pos = 5；继续遍历，当 j = 6 时，min = 56，pos = 6；然后将 nums[i] = nums[pos]，j++，pos = i++

第六轮排序，i = 6，j = 7，min = 90，tmp = 90，pos = 6；遍历，当 j = 7 时，min = 89，pos = 7；然后将 nums[i] = nums[pos]，j++，pos = i++

简单选择排序算法分析

简单选择排序的时间复杂度是 O(n^2)，空间复杂度是 O(1)，同时也是 不稳定排序（尝试将18改为34(绿标)初始位置换一下即可知），但是是一种 全局有序 的排序算法。

代码实现

class Solution{
public:
	void selectionSort(vector<int> &nums) {
		for(int i = 0; i < nums.size() - 1; i++) {
			int min = nums[i];
			int tmp = nums[i];
			int pos = i;
			for(int j = i+1; j < nums.size(); j++) {
				if(min > nums[j]) {
					min = nums[j];
					pos = j;
				}
			}
			nums[i] = nums[pos];
			nums[pos] = tmp;
		} 
	}
};

加工后执行的结果




堆排序(选择排序)

排序思想

堆排序是一种属性选择方法，它的特点是：在排序过程中，将 nums[0,n-1] 视为一棵完全二叉树的顺序结果，之所以采用完全二叉树，是因为完全二叉树与列表下标之间存在数学关系，比如完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无需去中选择关键字最大（最小）的元素

在介绍堆排序之前，首先要介绍一下 最大堆 和 最小堆，这是堆排序的前置基础。

大顶堆：nums[i] >= nums[2i+1] && nums[i] >= nums[2i+2]

大顶堆的文字描述：父结点的值比子结点的值都要大与或等于

小顶堆：nums[i] <= nums[2i+1] && nums[i] <= nums[2i+2]

小顶堆的文字描述：父结点的值比子结点的值都要小于或等于



详解堆排序的过程，首先是构造最大堆

  1. i = len / 2 - 1，此时 i = 2

  2. 令 k = 2 * i + 1 = 5（若存在左子结点，得到左子结点，即 k <= len）

  3. nums[k] = 34 ，nums[k++] =56(若存在兄弟结点)，兄弟结点比较，将指针 k 指向较大的结点

  4. 将较大的子结点与父结点比较，若子结点大于父结点，就交换位置

  5. 调整 k = 13 的结点（无）


  1. i --，此时 i = 1

  2. 令 k = 2 * i + 1 = 3（若存在左子结点，得到左子结点）

  3. nums[k] = 89 ，nums[k++] =90(若存在兄弟结点，即 k+1 < len)，兄弟结点比较，将指针 k 指向较大的结点

  4. 将较大的子结点与父结点比较，若子结点大于父结点，就交换位置

  5. 调整 k = 9 的结点（无）


  1. i --，此时 i = 0

  2. 令 k = 2 * i + 1 = 1（若存在左子结点，得到左子结点）

  3. nums[k] = 90 ，nums[k++] =56(若存在兄弟结点，即 k+1 < len)，兄弟结点比较，将指针 k 指向较大的结点

  4. 将较大的子结点与父结点比较，若子结点大于父结点，就交换位置

  5. 调整 k = 3的结点（无）



之后就是堆排序的内容，每一次排序之后，都要重新调整一次堆的结构，使堆称为大顶堆或者小顶堆

第一轮调整：当调整完大顶堆之后，将大顶堆堆顶元素与下标为i的元素交换。也就是说，i=6 , nums[6]=90（堆顶元素）,nums[0]=34（黄标）

第二轮调整：上一轮调整完毕之后，i-1，也就是说 i=5，按上面构造大顶堆的方法继续从下往上调整堆的元素，直至完成大顶堆。

当调整完大顶堆之后，将大顶堆堆顶元素与下标为 i 的元素交换。也就是说，i=5，nums[5]=89（堆顶元素）,nums[0]=34（绿标）



第三轮调整：上一轮调整完毕之后，i-1，也就是说 i=4，按上面构造大顶堆的方法继续从下往上调整堆的元素，直至完成大顶堆。

当调整完大顶堆之后，将大顶堆堆顶元素与下标为i的元素交换。也就是说，i=4，nums[4]=76（堆顶元素）,nums[0]=34（黄标）

第四轮调整：上一轮调整完毕之后，i-1，也就是说 i=3，按上面构造大顶堆的方法继续从下往上调整堆的元素，直至完成大顶堆。

当调整完大顶堆之后，将大顶堆堆顶元素与下标为 i 的元素交换。也就是说，i=3，nums[3]=56（堆顶元素）,nums[0]=23



第五轮调整：上一轮调整完毕之后，i-1，也就是说 i=2，按上面构造大顶堆的方法继续从下往上调整堆的元素，直至完成大顶堆。

当调整完大顶堆之后，将大顶堆堆顶元素与下标为i的元素交换。也就是说，i=2，nums[2]=34（黄标，堆顶元素）,nums[0]=23

最后轮调整：上一轮调整完毕之后，i-1，也就是说 i=1，按上面构造大顶堆的方法继续从下往上调整堆的元素，直至完成大顶堆。

当调整完大顶堆之后，将大顶堆堆顶元素与下标为i的元素交换。也就是说，i=1，nums[1]=34（绿标，堆顶元素）,nums[0]=23



了解了样式原理，就可以提炼总结

整个堆排序可以分为三个部分

第一部分，就是堆排序的本体

  1. 首先，对整个列表 n 个元素调整为最大堆（对应第二部分，调整堆的元素位置）
  2. 其次，自底向上，依次交换元素位置（对应第三部分，交换元素位置）
  3. 最后，就是继续对剩余的整个列表个元素调整为最大堆

第二部分，调整堆的位置

堆是一颗完全二叉树，也就是说，堆满足完全二叉树的全部性质，比如，父结点是 nums[i] 的话，子结点的位置分别是 nums[2i+1] 和 nums[2i+2]（假设len > 2i + 2的话），因此就有如下调整步骤

  1. 先取出当前元素 i，也就是末尾元素，存为 temp
  2. 从i结点的左子结点开始，也就是 k = 2 * i + 1 处开始
  3. 如果左子结点小于右子结点，k 指向右子结点，也就是 k++
  4. 如果子结点大于父结点，将子结点值赋给父结点（不用进行交换），但是要更新i的数值
  5. 继续到较大结点的左右结点（若存在），调整相应位置，即每一次为 2 * k + 1
  6. 调整的最后就是将更新后i的位置就是temp的位置

第三部分，交换元素位置

在调整为大顶堆之后

  1. 传入列表指针，栈顶也就是 0，和最后一个数字，也就是 i
  2. 将堆顶元素和最后一个元素交换

堆要注意的

堆排序向下调整的时间与树高有关，为 O(h)

堆序算法分析

堆排序的时间复杂度是 O(nlogn)，空间复杂度是 O(1)，但是通过前面示例中 34 和黄标和绿标的相对位置可以得知，堆排序是 不稳定排序，但它是 全局有序。

代码实现

class Solution{
public:
	void heapSort(vector<int> &nums) {
		// 1.构造大顶堆
		for(int i = nums.size() / 2 - 1; i >= 0; i--) {
			//从第一个非叶子结点从下至上，从右至左调整结构
			adjustHeap(nums,i,nums.size());
		} 
		//2.调整堆结构+交换堆顶元素与末尾元素
        for(int i = nums.size() - 1; i > 0; i--){
        	//将堆顶元素与末尾元素进行交换
            swap(nums, 0, i);
            //重新对堆进行调整
            adjustHeap(nums, 0, i);
        }
	}
private:
	//调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
    void adjustHeap(vector<int> &nums, int i, int len) {
     	// 先取出当前元素i
     	int temp = nums[i];
     	// 从i结点的左子结点开始，也就是2i+1处开始
        for(int k = 2 * i + 1; k < len; k = 2 * k + 1) {
        	// 如果左子结点小于右子结点，k指向右子结点
            if(k + 1 < len && nums[k]<nums[k+1]){
                k++;
            }
            //如果子结点大于父结点，将子结点值赋给父结点（不用进行交换）
            if(nums[k] > temp){
                nums[i] = nums[k];
                i = k;
            }else{
                break;
            }
        }
        //将temp值放到最终的位置
        nums[i] = temp;
	 }
	// 交换元素
    void swap(vector<int> &nums, int a ,int b){
        int temp=nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
};

加工后执行的结果


在这里插入图片描述

简单选择排序测试代码

#include <stdio.h>
#include <vector>
using namespace std;

class Solution{
public:
	void selectionSort(vector<int> &nums) {
		printf("第0轮：");
		for(int j = 0; j < nums.size(); j++) {
			printf("%d",nums[j]);
			if(j!=nums.size()-1) printf(",");
		}
		printf("\n");
		for(int i = 0; i < nums.size() - 1; i++) {
			int min = nums[i];
			int tmp = nums[i];
			int pos = i;
			for(int j = i+1; j < nums.size(); j++) {
				if(min > nums[j]) {
					min = nums[j];
					pos = j;
				}
			}
			nums[i] = nums[pos];
			nums[pos] = tmp;
			printf("第%d轮：", i+1);
			for(int j = 0; j < nums.size(); j++) {
				printf("%d",nums[j]);
				if(j!=nums.size()-1) printf(",");
			}
			printf("\n");
		} 
	}
};

int main() {
	vector<int> v;
	v.push_back(23);
	v.push_back(76);
	v.push_back(34);
	v.push_back(89);
	v.push_back(90);
	v.push_back(34);
	v.push_back(56);
	v.push_back(18);
	Solution solution;
	solution.selectionSort(v);
	return 0;
}

堆排序测试代码

#include <stdio.h>
#include <vector>
using namespace std;

class Solution{
public:
	void heapSort(vector<int> &nums) {
		// 1.构造大顶堆
		for(int i = nums.size() / 2 - 1; i >= 0; i--) {
			//从第一个非叶子结点从下至上，从右至左调整结构
			adjustHeap(nums,i,nums.size());
		} 
		int counter = 0;
		//2.调整堆结构+交换堆顶元素与末尾元素
        for(int i = nums.size() - 1; i > 0; i--){
        	printf("第%d轮：", counter++);
			for(int j = 0; j < nums.size(); j++) {
				printf("%d",nums[j]);
				if(j!=nums.size()-1) printf(",");
			}
			printf("\n");
        	//将堆顶元素与末尾元素进行交换
            swap(nums, 0, i);
            //重新对堆进行调整
            adjustHeap(nums, 0, i);
        }
        printf("第%d轮：", counter++);
			for(int j = 0; j < nums.size(); j++) {
				printf("%d",nums[j]);
				if(j!=nums.size()-1) printf(",");
			}
		printf("\n");
	}
private:
	//调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
    void adjustHeap(vector<int> &nums, int i, int len) {
     	//先取出当前元素i
     	int temp = nums[i];
     	//从i结点的左子结点开始，也就是2i+1处开始
        for(int k = 2 * i + 1; k < len; k = 2 * k + 1) {
        	//如果左子结点小于右子结点，k指向右子结点
            if(k + 1 < len && nums[k]<nums[k+1]){
                k++;
            }
            //如果子结点大于父结点，将子结点值赋给父结点（不用进行交换）
            if(nums[k] > temp){
                nums[i] = nums[k];
                i = k;
            }else{
                break;
            }
        }
        //将temp值放到最终的位置
        nums[i] = temp;
	 }
	// 交换元素
    void swap(vector<int> &nums, int a ,int b){
        int temp=nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
};

int main() {
	vector<int> v;
	v.push_back(23);
	v.push_back(76);
	v.push_back(34);
	v.push_back(89);
	v.push_back(90);
	v.push_back(34);
	v.push_back(56);
	Solution solution;
	solution.heapSort(v);
	return 0;
}
【排序算法】图解简单选择排序(图解堪比Debug显示每次循环结果)
baidu_33146219的博客
08-06 2万+
本文主要介绍简单选择排序算法，通过图片一步步解释每一趟每一次的后移。代码通过C#实现，并输出每一次交换的情况和比较次数，方便各位小伙伴比较算法的优缺点。图解堪比Debug，一步步分析每次循环结果。...
通俗易懂讲解 [图解]选择排序
youif的博客
05-15 6292
文章目录1.选择排序2. 图示过程3.动图展示4.约定5.过程6.代码 1.选择排序 从数组中选择最小元素，将它与数组的第一个元素交换位置。再从数组剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。 选择排序需要 ~N2/2 次比较和 ~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。 2. 图示过程 3.动图展示 4.约定 待排序的元素需要实现 Java 的 Comparable 接口，该接口有 c
排序算法（一）选择排序（简单选择排序、堆排序）思想图解及代码
cxchangzheng的博客
07-30 832
今天来总结一下著名的八大排序算法中的选择排序中的两种排序，为什么从这里开始讲，不知道，随便吧，从哪里开始都行。 其实初学我也总是忘记，函数名和参数写好之后就开始发呆了，我自己的一些经验来看：对于每种排序算法我们首先得了解核心思想，然后根据这个核心思想可以进行几轮的手动排序，从中得到核心代码，再由核心代码再完整的写出来整个排序算法。当然了，大佬完全可以在脑子里面进行动态的转换的…我就不行了。 所以我会主要记录一下前两步，也方便自己后面的复习。 1.简单选择排序： 再写代码之前再说几句：无论是我还是正在读文
【一看就懂的图解算法】简单选择排序
weixin_43878297的博客
09-25 6784
简单选择排序 冒泡排序是将最大的元素往后面排，简单选择排序是将小的元素往前面排 算法思想： 1.将第一个元素和其余元素进行对比，如果第一个元素和其他元素相比，第一个元素大，则交换，一轮下来，最小的元素会在第一个 2.将第二个元素和其余的元素对比，如果对比结果大，则交换 3.重复 算法图解： 以此类推…… Java代码： void simpleSort(int[] a){ int t...
【排序算法】选择排序的全面剖析（含详细图解）
A Charmer 的博客
10-13 1万+
本文深入解析选择排序算法。介绍了选择排序的原理，即每次从待排序元素中选出最小元素放在已排序部分末尾。详细阐述了选择排序的实现步骤，包括以升序为例的遍历找最小元素、交换位置等过程，并通过代码示例和具体数组示例进行说明。分析了选择排序的时间复杂度、空间复杂度和稳定性，还将其与冒泡排序、插入排序、快速排序进行比较，包括时间复杂度、稳定性、代码实现复杂度、适用场景等方面。最后总结选择排序简单易懂，适用于数据量小且对效率要求不高的场景，是理解排序算法基本思想的良好学习案例。
堆排序算法（图解详细流程）
热门推荐
wenwenaier的博客
11-14 4万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录堆排序基本介绍大顶堆举例说明小顶堆举例说明堆排序的基本思想堆排序步骤图解说明堆排序的基本思路总结 堆排序基本介绍 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏最好，平均时间复杂度均为O(nlogn)，他也是不稳定排序 堆是具有以下性质的完全二叉树，每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆，注意：没有要求节点的左孩子的值和右孩子的值的大小关系。 每个结点的值都小于或等于其左
数据结构六大排序详解（插入排序、希尔排序、选择排序、冒泡排序、快速排序、堆排序）
weixin_45796387的博客
09-20 6583
1、排序的概念 1、排序的概念 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。 内部排序：数据元素全部放在内存中的排序。 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据
堆排序（超详细图解 java版）
Javascript_tsj的博客
04-09 1万+
堆排序基本介绍 l) 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为0(nlogn)，它也是不稳定排序。 2)堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆,注意:没有要求结点的左孩子的值和右孩子的值的大小关系。 3)每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆 4)大顶堆举例说明 5)小顶堆举例说明 6) 一般升序采用大顶堆，降序采用小顶堆 堆排序基本思想 堆排序的基本思想...
数据结构七大排序算法图解——选择排序动图演示
最新发布
二哈喇子！
01-23 7472
详细整理——直接选择排序+树形排序+堆排序（代码+动图演示） ...
简单选择排序流程图_图解排序算法：3种简单排序(选择、冒泡、直接插入)
weixin_42644410的博客
01-27 7008
来自：dreamcatcher-cx链接：cnblogs.com/chengxiao/p/6103002.html00 前言排序是数据处理中十分常见且核心的操作，虽说实际项目开发中很小几率会需要我们手动实现，毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些精妙的思想对我们还是大有裨益的。本文简单温习下最基础的三类算法：选择、冒泡、插入。先定义个交换数组元素的函数，供排...
选择排序
qq_35169931的博客
01-18 301
一、选择排序 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已盘排序序列的末尾。以此类推，直到所有元素均排序完成 选择排序的主要优点与数据移动有关。如果某个元素为与正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，他们当中至少有一个将被移动到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在...
【十大排序算法】----选择排序（详细图解分析+实现，小白一看就会）
2302_78684687的博客
05-13 1万+
在选择排序中，我们是可以将其优化的，即可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。的原理：通过遍历数组，选出该数组中较大的或者较小的，放在数组的起始位置，当遍历完整个数组时排序完成。选择排序是最简单的排序之一，最大的优点就是好理解，不过因为其效率低下，所以在一般情况下不使用。：当一个数已经知道其是 最大/最小 ，并已经将其进行交换之后，那么这个位置是万万不可变动的。当经过 N-1 趟的遍历交换之后，该序列就实现的从小到大的排列了。
选择排序（图解全过程，看完就会）
qq_50355115的博客
08-26 7537
选择排序 所谓选择排序，顾名思义就是要靠选择进行排序 就如同打扑克 将手上的牌由小到大进行排序 如下图： 那么该如何实现图片中的操作呢？ 我准备了一些简略的图片，方便大家理解 上图还原了原GIF中的排序过程 选择数列的最大值 放在数列的最开头 然后重复这一步骤 接着我们给出c++代码 for (int i=0;i<n-1;i++){ for(int j=i+1;j<n;j++) if(a[j]<a[i]){ int p = a[i]; a[i]=a[j]; a
图解排序算法之3种简单排序(选择，冒泡，直接插入)
tecoes的博客
05-05 3104
排序是数据处理中十分常见且核心的操作，虽说实际项目开发中很小几率会需要我们手动实现，毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些精妙的思想对我们还是大有裨益的。本文简单温习下最基础的三类算法：选择，冒泡，插入。 先定义个交换数组元素的函数，供排序时调用 简单选择排序 　　简单选择排序是最简单直观的一种算法，基本思想为将序列分为有序序列和待排的无序序列，每一趟从后面n-i个待排数据元素中选择最小的一个元素作为有序序列的第i个元素，直到所有元素排完为止。 　　在算法实现时，每一趟确定最
数据结构之排序【直接选择排序和堆排序的实现及分析】内含动态演示图
狂小伍的博客
12-25 1320
包含动态演示图，并且每一句代码都是详解
【八大数据排序法】选择排序法的图形理解和案例实现 | C++
PIONEER
02-01 940
排序算法是我们在程序设计中经常见到和使用的一种算法，它主要是将一堆不规则的数据按照递增或递减的方式重新进行排序。在如今的互联网信息时代，随着大数据和人工智能的发展，大型企业的数据库中有亿级的用户数据量。因此对其进行处理，排序算法也就成为了其中必不可缺的步骤之一。
算法分析：采用蛮力法(循环)完成一维整型数组的简单选择排序算法首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。
Name Yan
09-20 392
一、效果图 二、源代码 package sy3; /** * @author * */ public class Sy3_2 { static void selectSort(int a[]) { for (int i = 0; i < 7; i++) {// 多次选择 // 一次选择 int k = i;// 记录最小值所在的下标 for (int j = i + 1; j < 7; j++) { if (a[k] > a[j]) { k = j...
八大排序算法详解（动图演示 思路分析 实例代码java 复杂度分析 适用场景）
bytes9的专栏
10-30 1122
一、分类 1.内部排序和外部排序　 内部排序：待排序记录存放在计算机随机存储器中（说简单点，就是内存）进行的排序过程。 外部排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行访问的排序过程。 2.比较类排序和非比较排序 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性...
选择排序（图解）
qq_33289077的博客
05-16 3万+
选择排序 选择排序是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。 选择排序的方法主要有两种，分别是简单选择排序以及堆排序，它们都是从待排序的数据元素中选择合适的元素放到合适的位置来进...
插入排序和选择排序
zjx624bjh的博客
05-18 3411
排序：将一组杂乱无章的数据按照一定的规则有组织地排列起来。 排序的稳定性：如果在排序中，存在前后相同的两个元素的话，排序前和排序后他们的相对位置不发生变化。 今天，先来学习插入排序和选择排序： 插入排序 直接插入排序 （1）思想： 每一步将一个待排序的元其排序码的大小，插入到前面已将排好序的一组元素的合适位置上去，直到全部元素插入完为止。 元素集合越接近有序，直接插入排...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_之桐_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值