简单选择排序 订阅
简单选择排序是一种排序算法,指在简单选择排序过程中,所需移动记录的次数比较少。 展开全文
简单选择排序是一种排序算法,指在简单选择排序过程中,所需移动记录的次数比较少。
信息
定    义
排序算法 数据结构
分    类
数据结构
中文名
简单选择排序
外文名
Select Sort
简单选择排序基本概念
最好情况下,即待排序记录初始状态就已经是正序排列了,则不需要移动记录。最坏情况下,即待排序记录初始状态是按第一条记录最小,之后的记录从小到大顺序排列,则需要移动记录的次数最多为3(n-1)。简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况无关。当i=1时,需进行n-1次比较;当i=2时,需进行n-2次比较;依次类推,共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2,即进行比较操作的时间复杂度为O(n^2),进行移动操作的时间复杂度为O(n)。简单选择排序是不稳定排序。
收起全文
精华内容
下载资源
问答
  • 简单选择排序
    千次阅读
    2018-08-02 17:31:48

    基本思想:

            在待排序数组中选出最小的(或最大)的与第一个位置的数据交换 然后在剩下的待排序数组中找出最小(或最大)的与第二个位置的数据交换,以此类推,直到第n-1个元素。

            简单选择排序可以说是冒泡排序的一种改版,它不再两两比较出较小数就进行交换,而是每次遍历比较当前数的后面所有数,最后再把最小的数和当前数进行交换。

    图解:

    代码实现:

    void selectSort(int arr[], int len)
    {
    	int i, j;
    	int min; //待排序数组中最小值的下标
    	int tmp;
    	for (i = 0; i < len - 1; ++i)//i = 0,第一次待排数组为所有数
    	{   
    		min = i;
    		for (j = i + 1; j < len; ++j)
    		{
    			if (arr[j] < arr[min])
    			{
    				min = j;//
    			}
    		}
    		//将arr[i]与arr[min]交换位置
    		tmp = arr[i];
    		arr[i] = arr[min];
    		arr[min] = tmp;
    	}
    }
    void selectShow(int arr[], int len)
    {
    	for (int i = 0; i < len; ++i)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    }
    int main()
    {
    	int arr[] = {59,26,245,21,6,10,16};
    	int len = sizeof(arr) / sizeof(arr[0]);
    	selectShow(arr, len);
    	selectSort(arr, len);
    	selectShow(arr, len);
    	return 0;
    }

    总结:

    时间复杂度:平均O(n2),最好O(n2),最坏O(n2)

    空间复杂度:O(1)

    不稳定的排序算法

    更多相关内容
  • 冒泡排序 简单选择排序 c语言基础 排序算法 数组操作 排序算法实验 简单的c语言程序 排序算法输出
  • 简单选择排序及实例 C语言代码实现 Python代码实现 简单选择排序 简单选择排序是选择排序的一种。 问:那么什么是选择排序? 答:每趟从待排序的记录中选出关键字最小的元素,顺序放在已排序的记录序列末尾,直到...

    博客对您有所帮助的话,欢迎给个赞啦,你的鼓励是对我最大的支持! 有不足之处也请您评论指教


    简单选择排序

    简单选择排序是选择排序的一种。

    问:那么什么是选择排序?

    答:每趟从待排序的记录中选出关键字最小的元素,顺序放在已排序的记录序列末尾,直到全部排序结束为止。

    1 简单选择排序的思想与流程

    从上文“什么是选择排序”,引申出简单选择排序的思想;

    ①从待排序数组元素中,找到值最小的元素;

    ②将值最小的元素与待排序数组元素的第一个元素互换;

    ③重复(元素个数-1轮次)①②,至此直到数组元素排序完成。

    2 实例介绍

    下面将某个实例和图片来介绍简单选择排序的思想和代码;

    假设数组为:

    a r r = [ 5 , 2 , 4 , 6 , 1 , 3 ] arr=[5, 2, 4, 6, 1, 3] arr=[5,2,4,6,1,3]

    :下方介绍的图片显示颜色为就是已经排好的元素,显示为红色就是标记目前值最小的元素,显示为绿色就是正在遍历数组剩下的元素

    1.第一轮(如动图1所示)

    把未排序数组的第一个元素设为最小值(在本例中,设数组元素 5 为最小值,min=5),然后依次遍历剩下的元素。

    ①遍历第一个元素为2,2<5,故2设为最小值,min=2;
    ②遍历第二个元素为4,4>2,继续往后遍历;
    ③遍历第三个元素为6,6>2,继续往后遍历;
    ④遍历第四个元素为1,1<2,故1设为最小值,min=1;
    ⑤遍历第五个元素为3,3>1,继续往后遍历,后面没有元素,故将值最小的元素与待排序数组元素的第一个元素互换,1与5互换,元素1排序完毕,此时数组元素依次为1 2 4 6 5 3.

    此时待排序数组依次为 2 4 6 5 3

    请添加图片描述
    图 1   简 单 选 择 排 序 第 一 轮 图1~简单选择排序第一轮 1 

    2.第二轮(如动图2所示)

    把未排序数组的第一个元素设为最小值(此时,min=2),然后依次遍历剩下的元素。

    ①遍历第一个元素为4,4>2,继续往后遍历;
    ②遍历第二个元素为6,6>2,继续往后遍历;
    ③遍历第三个元素为5,5>2,继续往后遍历;
    ④遍历第四个元素为3,3>2,继续往后遍历,后面没有元素,故将值最小的元素与待排序数组元素的第一个元素互换,第一个元素是其本身,故不动,元素2排序完毕,此时数组元素依次为1 2 4 6 5 3.

    此时待排序数组依次为 4 6 5 3
    请添加图片描述
    图 2   简 单 选 择 排 序 第 二 轮 图2~简单选择排序第二轮 2 

    3.第三轮(如动图3所示)

    把未排序数组的第一个元素设为最小值(此时,min=4),然后依次遍历剩下的元素。

    ①遍历第一个元素为6,6>4,继续往后遍历;
    ②遍历第二个元素为5,5>4,继续往后遍历;
    ③遍历第三个元素为3,3<4,故3设为最小值,min=3,继续往后遍历,后面没有元素,故将值最小的元素与待排序数组元素的第一个元素互换,3与4互换,元素3排序完毕,此时数组元素依次为1 2 3 6 5 4.

    此时待排序数组依次为 6 5 4

    请添加图片描述
    图 3   简 单 选 择 排 序 第 三 轮 图3~简单选择排序第三轮 3 

    4.第四轮(如动图4所示)

    把未排序数组的第一个元素设为最小值(此时,min=6),然后依次遍历剩下的元素。

    ①遍历第一个元素为5,6>5,故5设为最小值,min=5;
    ②遍历第二个元素为4,5>4,故4设为最小值,min=4,继续往后遍历,后面没有元素,故将值最小的元素与待排序数组元素的第一个元素互换,4与6互换,元素4排序完毕,此时数组元素依次为1 2 3 4 5 6.

    此时待排序数组依次为 5 6

    请添加图片描述
    图 4   简 单 选 择 排 序 第 四 轮 图4~简单选择排序第四轮 4 

    5.第5轮(如动图5所示)

    把未排序数组的第一个元素设为最小值(此时,min=5),然后依次遍历剩下的元素。

    ①遍历第一个元素为6,5<6,继续往后遍历,后面没有元素,故将值最小的元素与待排序数组元素的第一个元素互换,第一个元素是其本身,故不动,元素5排序完毕,此时数组元素依次为1 2 3 4 5 6.

    此时待排序数组依次为 6

    请添加图片描述
    图 5   简 单 选 择 排 序 第 五 轮 图5~简单选择排序第五轮 5 

    最后一个元素不需要排序

    此时经过5轮排序,排序完毕。

    3 算法分析

    3.1 时间复杂度

    对于简单选择排序来说,无论初始数组元素是什么状态,其排序趟数永远是(元素个数-1)躺,元素间的比较始终为 O ( n 2 ) O(n^{2}) O(n2),而元素间的移动次数与初始状态有关,但上限为 O ( n ) O(n) O(n);
    所以简单选择排序最好、最坏、平均时间复杂度均为 O ( n 2 ) O(n^{2}) O(n2)

    3.2 空间复杂度

    常数个辅助空间: O ( 1 ) O(1) O(1)

    3.3 稳定性

    不稳定

    4 代码实现

    4.1 C语言代码

    #include<stdio.h>
    int main()
    {
    	void select_sort(int arr[], int len);
    	int arr[6] = { 5,2,4,6,1,3 };
    	int len=sizeof(arr)/sizeof(int);
    	int i;
    	printf("排序之前的数组元素依次为:");
    	for(i=0;i<len;i++)
    	{
    		printf("%d ",arr[i]);
    	}
    	printf("\n"); 
    	select_sort(arr,len);
    	printf("排序之后的数组元素依次为:");
    	for(i=0;i<len;i++)
    	{
    		printf("%d ",arr[i]);
    	}
    	printf("\n"); 
    	return 0; 
    } 
    void select_sort(int arr[], int len)
    {
    	int i,j;
    	int min;
    	int temp;
    	int k;
    	for(i=0;i<len-1;i++)
    	{
    		min = i;
    		for(j=i+1;j<len;j++)
    		{
    			if(arr[j]<arr[min]) min = j;
    		}
    		if(min!=i) 
    		{
    			temp = arr[i];
    			arr[i] = arr[min];
    			arr[min] = temp;
    		}
    		// 输入排序每轮结果
    		printf("第%d轮",i+1);
    		for(k=0;k<len;k++)
    		{
    			printf("%d ",arr[k]);
    		}
    		printf("\n");
    	}
    }
    

    运行结果:
    在这里插入图片描述
    图 6   C 语 言 代 码 运 行 结 果 图6~C语言代码运行结果 6 C

    4.2 Python语言代码

    def simpleselect_sort(List, len):
        ''' Function description: selection sort
        Parameters:  List:待排序数组 len:待排序数组长度 return:升序数组
        Author: kent4ngw
        Address: https://blog.csdn.net/t4ngw '''
        for i in range(len-1):
            min = i
            for j in range(i+1, len):
                if(List[j] < List[min]):
                    min = j
            if(min != i):
                List[i], List[min] = List[min], List[i]
        return List
    List = [5, 2, 4, 6, 1, 3]
    print("简单选择排序前的数组:")
    print(List)
    print("简单选择排序后的数组:")
    print(simpleselect_sort(List, len(List)))
    
    # 不稳定
    

    运行结果:
    在这里插入图片描述
    图 7   P y t h o n 语 言 代 码 运 行 结 果 图7~Python语言代码运行结果 7 Python

    1.5 参考文献

    [1]王道论坛. 2022年数据结构考研复习指导[M]. 北京:电子工业出版社, 2021.


    写在最后面的话,此博客为个人通过书本和互联网作为学习资源自己整理而成的笔记,仅作为知识记录及后期复习所用,如有错误,还望评论指教 ——kent4ngw.

    展开全文
  • 冒泡排序、快速排序、简单插入排序、希尔排序、简单选择排序、堆叠排序六种数据结构必考的排序方式理解
  • 数据结构-排序(六)简单选择排序

    千次阅读 2022-03-20 08:38:38
    本文详细介绍了简单选择排序的算法思想、代码实现和算法效率分析,还包括示例和可视化动图,易理解!

    本文详细介绍了简单选择排序的算法思想、代码实现和算法效率分析,还包括示例和可视化动图,易理解!
    Let’s go!🏃‍♂️

    数据结构-排序(六)简单选择排序

    一、算法思想

    选择排序算法思想: 每⼀趟在待排序元素中选取关键字最小(或最大)的元素加入有序子序列。n个元素的简单选择排序需要 n-1 趟处理

    在这里插入图片描述
    以上gif动图制作,图像来自网站:VisuAlgo

    二、代码实现

    #include <iostream>
    #include <string>
    using namespace std;
    
    /**
     * 简单选择排序
     * @param arr
     * @param n
     */
    void SelectSort(int arr[], int n) {
        for (int i = 0; i < n - 1; i++) { //n - 1趟
            int min = i; //记录最小元素位置
            for (int j = i + 1; j < n; j++) { //再arr[i...n-1]中选择最小元素
                if (arr[j] < arr[min]) { //更新最小位置
                    min = j;
                }//if
            }//for
            if (min != i) { //交换最小值
                swap(arr[i], arr[min]); //交换顺序
            }
        }//for
    }
    /**
     * 输出数组
     * @param arr
     * @param n
     */
    void PrintArray(int arr[], int n) {
        for (int i = 0; i < n; i++) {
            cout << arr[i] << "  ";
        }
        printf("\n");
    }
    int main() {
        int arr[] = {12, 28, 20, 50, 48, 1, 5, 28};
        int n = sizeof(arr) / sizeof(arr[0]);
        cout << "输出arr初始数组" << endl;
        PrintArray(arr, n);
        cout << "arr简单选择排序" << endl;
        SelectSort(arr, n);c
        cout << "输出arr排序后数组" << endl;
        PrintArray(arr, n);
        return 0;
    }
    

    三、算法效率分析

    1、空间复杂度: O(1)

    2、时间复杂度

    ⽆论有序、逆序、还是乱序,⼀定需要 n-1 趟处理

    比较次数 = (n - 1) + (n - 2 )+…+ 1 = n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n1) ;交换次数 < n - 1;

    时间复杂度: O ( n 2 ) O(n^2) O(n2)

    3、稳定性: 不稳定

    4、适⽤性: 既可以用于顺序表,也可用于链表

    下一篇👉数据结构-排序(七)堆排序

    展开全文
  • 排序算法5——简单选择排序

    千次阅读 2019-11-11 08:22:16
    选择排序主要有两种:简单选择排序和堆排序。 【简单选择排序】 编写算法,要求使用简单选择排序算法对元素65、32、71、28、83、7、53、49进行从小到大排序。 【算法思想】 简单选择排序是一种简单的选择类排序...

    选择排序就是从待排序的元素中选择最小(最大)的元素,将其放在有序序列的相应位置,使这些元素构成有序序列。选择排序主要有两种:简单选择排序和堆排序。


    【简单选择排序】

    编写算法,要求使用简单选择排序算法对元素65、32、71、28、83、7、53、49进行从小到大排序。

    【算法思想】

    简单选择排序是一种简单的选择类排序算法,它的基本思想描述如下:

    假设待排序的元素有n个,在第一趟排序过程中,从n个元素序列中选择最小的元素,并将其放在元素序列的最前面,即第一个位置。在第二趟排序过程中,从剩余的n-1个元素中,选择最小的元素,将其放在第二位置。以此类推,直到没有待比较的元素,简单选择排序算法结束。

    例如:

    给定一组元素序列:55、33、22、66、44。简单选择排序的过程如下:


    * 第一趟排序:从第1个元素开始,将第1个元素与第2个元素进行比较,因为55>33,所以33是较小的元素;继续将33与第3个元素22比较,因为33>22,所以22成为较小的元素;将22与第4个元素66比较,因为22<66,所以22仍然是比较小的一个元素;最后将22与第5个元素44比较,因为22<44,所以22就是这5个元素中最小的一个元素,并将22与第1个元素交换,此时,完成第1趟排序。第1趟排序过程如下图:

    初始时,假设最小元素的下标为0。在比较过程中,用j记下最小元素的下标。经过第1趟排序后,最小的元素位于第1个位置上(处于正确的位置)。

    *第二趟排序:从第2元素开始,将第2个元素与第3个元素进行比较,因为33<55,所以33是较小的元素;继续将33与第4个元素66比较,因为33<66,所以33仍然是较小的元素;将33与第5个元素44进行比较,因为33<44,所以33就是最小的元素,并将33与第2个元素进行交换,此时,完成第2趟排序。第2趟排序过程如下图。


    在第2趟排序过程中,33收最小的元素,本身就在第2个位置,不需要移动元素。

    *第三趟排序:从第3个元素开始,将第3个元素和第4个元素进行比较,因为55<66,所以55是较小的元素;继续将55与第5个元素44比较,因为55>44,所以44是较小的元素,并将44与第3个元素交换,此时,完成第3趟排序,过程如下:

    到目前为止前三个元素都已经有序,接下来只需确定第四个元素和第五个元素的顺序即可。


    *第四趟排序:比较第4个元素与第5个元素,即66与55的大小,因为66>55,所以55是较小的元素,并将66与55交换,此时,完成第4趟排序。第4趟排序过程如图所示。

    此时,前4个元素都已经有序且位于正确的位置上,那么,第5个元素也位于正确的位置上。因此,整个简单选择排序结束。


    【示例】

    假设待排序元素有8个,分别是65、32、71、28、83、7、53、49。使用简单选择排序对该元素序列过程如图所示。

    在简单选择排序过程中,如果待排序元素的个数为n,则需要n-1趟剖需要。对于第i趟排序,需要比较的次数为i-1。当第i趟排序完毕,将该趟排序过程中最小的元素放在第i个位置,此时,前i个元素都已经有序且在正确的位置上。

    code:

    #include<stdio.h>
    void SelectSort(int a[], int n);
    void DispArray(int a[], int n);
    void main()
    {
    	int a[] = { 65,32,71,28,83,7,53,49 };
    	int n = sizeof(a) / sizeof(a[0]);
    	printf("排序前:\n");
    	DispArray(a, n);
    	SelectSort(a, n);
    	printf("最终排序结果:");
    	DispArray(a, n);
    	getchar();
    }
    void SelectSort(int a[], int n)
    /*简单选择排序*/
    {
    	int i, j, k, t;
    	/*将第i个元素与第i+1...n个元素比较,将最小的的元素放在第i个位置*/
    	for (i = 0; i<n - 1; i++)
    	{
    		j = i;
    		for (k = i + 1; k<n; k++)	/*最小的元素的序号为j*/
    			if (a[k]<a[j])
    				j = k;
    		if (j != i)			/*如果序号i不等于j,则需要将序号i和序号j的元素交换*/
    		{
    			t = a[i];
    			a[i] = a[j];
    			a[j] = t;
    		}
    		printf("第%d趟排序结果:", i + 1);
    		DispArray(a, n);
    	}
    }
    void DispArray(int a[], int n)
    /*输出数组中的元素*/
    {
    	int i;
    	for (i = 0; i<n; i++)
    		printf("%4d", a[i]);
    	printf("\n");
    }
    

     result:

    【主要用途】

    简单选择排序算法实现简单,适用于排序元素较少且对时间要求不高的场合。

    【稳定性与复杂度】

    简答选择排序森一种不稳定的排序算法。在最坏的情况下,待排序的严肃序列按照非递减排列,则不要移动元素。在最坏的情况下,待排序元素按照非递增排列,则在每一趟都需要移动元素,移动元素的次数为3(n-1)。在任何情况下,简单选择排序算法都需要进行n(n-1)/2 的比较。综上,简单选择排序算法的时间复杂度是O(n^2)。简答选择排序的空间复杂度为O(1)。

    展开全文
  • 用函数实现简单选择排序,并输出每趟排序的结果 输入格式 第一行:键盘输入待排序关键的个数n 第二行:输入n个待排序关键字,用空格分隔数据 输出格式 每行输出每趟排序的结果,数据之间用一个空格分隔 输入...
  • 简单选择排序(C语言)

    千次阅读 2020-06-18 15:59:39
    简单选择排序 1.排序原理 简单选择排序算法原理:每次从左至右扫描序列,记下最小值的位置。然后将最小值与当前位置的值交换 排序过程 序列:[5 4 3 2 1] 从小到大排列 第一轮:[(5) 4 3 2 1] 当前位置:[5] [4,...
  • 选择类:简单选择排序、堆排序 归并类:二路归并排序 基数类:多关键字排序 九种算法的时间复杂度、空间复杂度和稳定性小结如下: 本文放出选择算法的两种排序算法代码。 简单选择排序 void SelectSort(int R[], ...
  • 简单选择排序算法

    千次阅读 2021-04-20 12:55:01
    简单选择排序算法 基本策略 每次从无序序列中选出一个关键字最大(最小)的记录添加到有序序列尾部 基本思想 第一趟:从长度为len的序列中选出关键字最大(最小)的记录与第1个记录交换 第二趟:从第2个数据...
  • 选择排序之简单选择排序

    千次阅读 2022-02-14 00:36:23
    1.引言一听到选择排序的词第一反应都是要通过选择来排序,那么我们的第一反应是不是对的呢,我们接下来验证一下,了解一下它的定义。简单选择排序:最简单的选择方法是顺序扫描序列中的元素,记住遇到...
  • 选择排序 图示过程如下:
  • 简单选择排序的稳定性

    千次阅读 2020-12-23 11:07:05
    不稳定的简单选择排序
  • 【数据结构】-排序-基于单链表的简单选择排序

    千次阅读 多人点赞 2020-07-12 11:08:18
    方法一:不进行任何断链插入操作,找到目标节点之后,只是交换data值,这个思路很简单,与简单选择排序的思路一摸一样。 编程注意事项: min不能标记最小值,应该要标记最小值对应的链表节点 LinkList create...
  • C语言 简单选择排序

    千次阅读 2021-01-27 11:40:08
    简单选择排序是指一种排序算法,在简单选择排序过程中,所需移动记录的次数比较少。最好情况下,即待排序记录初始状态就已经是正序排列了,则不需要移动记录。 一、基本思想 在要排序的一组数中,选出最小的一个数与...
  • 一、代码 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 20 #define ERROR 0 #define OK 1 typedef int Status; void selectSort(int data... printf("请输入待排序的数组大小:"); if(scanf
  • 七种排序算法(包括直接插入排序,折半插入排序,希尔排序,冒泡排序,快速排序,简单选择排序,归并排序) 还有两道题 1./*设计并实现一个有效的对n个整数重排的算法,使得所有负数位于非负数之前,给出算法的性能...
  • 【链表】简单选择排序

    千次阅读 2019-12-26 14:54:15
    编写一个算法,在基于单链表表示的待排序关键字序列上进行简单选择排序。 算法思想: 每趟在原始链表中摘下关键字最大的结点,把它插入到结果链表的最前端,由于在原始链表中摘下的关键字越来越小,在结果链表前端...
  • 线性表的排序算法排序相关的几个基本概念直接插入排序简单插入排序)基本思想代码示例性能分析空间复杂度时间复杂度冒泡排序基本思想 排序相关的几个基本概念 排序依据是指数据元素的关键字,若关键字是主关键字...
  • 1.设计一个程序,用于演示直接插入排序法、冒泡排序法或简单选择排序法,要求采用菜单的形式进行选择。 2.测试数据:265,301,751,129,937,863,742,694,76,438 3.测试:分别用上面的数据测试直接插入排序法...
  • (1)掌握线性表的存储方式,并在此基础上实现典型的排序算法 (2)理解并掌握内部排序中几种常用算法的性能和适用场合 (3)理解并比较各种排序算法的时间复杂度和空间复杂度
  • 简单选择排序(顺序存储、链式存储)、堆排序(顺序存储)   选择排序分为简单选择排序和堆排序。其基本思想是:每一趟(如第i趟)在后面n-i+1(i=1,2,…,n-1)个待排序元素中选关键字最小的元素,作为有序子...
  • 这六种排序算法在排序中非常常用,使用频率较高,故记录一下,以后自己忘了还能看一下。 直接插入排序:这个算法起源将一个数据插入到一个有序的数列中。从后往前一个一个比较,当找到插入点时,直接插入,不影响...
  • 冒泡排序、直接插入排序、简单选择排序 冒泡排序、直接插入排序、简单选择排序 冒泡排序、直接插入排序、简单选择排序
  • C++实现排序算法之简单选择排序

    千次阅读 2020-07-16 15:07:27
    在待排序的数据中选择最大(小)的元素放在其最终的位置 基本操作: 1.首先通过n-1次关键字的比较,从n个记录中找出关键字最小的记录,将它与第一个记录交换 2.再通过n-2次比较,从剩余的n-1个记录中找出关键字次小...
  • 数据结构简单排序算法一、直接插入排序升序代码示例:降序代码示例:二、冒泡排序三、简单选择排序 简单排序算法   数据结构是科班同学们必学的课程,当然这门课程并不是那么好学,有些同学一点就透,有些同学就...
  • 以单链表为存储结构实现简单选择排序的算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 554,864
精华内容 221,945
关键字:

简单选择排序