算法实例选择排序法
拓展知识6-1 选择排序
拓展知识6-1 选择排序在【例6-2】冒泡排序的算法中，整个排序过程共进行了N-1趟，总的比较次数为N*(N-1)/2次，而每次比较后都可能做交换操作，总交换次数大约是比较次数的一半，特别对原N个数据已是降序排列的极端情况，每次比较后都要做交换操作，这些交换操作降低了算法的效率，针对这一问题有人提出了一种改进方法，大大降低了交换次数，这种方法就是选择排序。
1．选择排序法的基本思想先从a[0]，a[1]，…，a[N-1]中选出一个最小数记为a[p]，若p≠0，将a[p]与a[0]交换，这样比较一轮后，最小数放在了a[0]中；再从a[1],a[2]，…，a[N-1]中选出一个最小数a[p]，若p≠1，将a[p]与a[1]交换，经第二轮比较后，把第二小的数放在了a[1]中；如此进行下去，便可将N个数由小到大进行排序。
（1）整个排序过程共需N-1趟；（2）第i趟共比较N-i次；（3）每趟最多交换一次。
2．第i趟排序过程先认定a[i]最小，即记p=i；再从j=i+1开始，将a[j]与a[p]比较，若a[j]<a[p]，将j赋给p，即p=j，继续将下一个数与a[p]比较，直到a[N-1] 与a[p]比较完毕，a[p]中存放的就是a[i]，a[i+1]，…，a[N-1]中最小的，如果p≠i，就将a[i]与a[p]交换，第i趟排序结束。
程序代码（只给出选择排序函数SelectSort）如下：（1）void SelectSort(int a[N])（2）{（3）int i,j,p,temp;（4）for(i=0;i<N-1;i++)（5）{（6）p=i;（7）for(j=i+1;j<=N-1;j++)（8）{（9）if(a[j]<a[p])（10）p=j;（11）}（12）if(p!=i)（13）{（14）temp=a[p];（15）a[p]=a[i];（16）a[i]=temp;（17）}（18）}（19）}选择排序与冒泡排序相比较，冒泡排序需要交换的次数多（平均交换N*(N-1)/4次），而选择排序最多只需要N-1次交换。
简单选择排序C语言
算法原理：通过相邻元素比较和交换，将较大的元素逐渐往后移动 时间复杂度：O(n^2)，其中n为元素数量 空间复杂度：O(1)，即算法只需要常数级别的额外空间 适用场景：适用于小规模数据的排序，但对于大规模数据排序效率较低
时间复杂度：简单选 择排序的时间复杂度 为O(n^2)，与其他排 序算法相比可能较慢
快速排序算法的时间复杂度为O(nlogn)，在平均情况下比简单选择排序和冒泡排序更高效。
快速排序算法的空间复杂度为O(logn)，需要额外的空间来存储递归调用的函数栈。
快速排序算法在处理大数据集时表现优秀，但在最坏情况下（输入数据已经有序或接近有序）的时间复杂度会退 化到O(n^2)。
空间复杂度：O(1)，因为算法只需 要常数级别的额外空间。
添加标题
添加标题
添加标题
添加标题
时间复杂度：最好、最坏和平均情 况下为O(n^2)，其中n是数组长度。
适用场景：对于小规模数据的排序， 插入排序相对简单且易于实现。
快速排序算法的基本思想是采用分治法，将数组分成两个子数组，分别对子数组进行排序，然后合并成一个有序 数组。
代码示例：下面是一个简单的C语言实现简单选择排序的代码示例，可以帮助理解算法的实现过程。
注意事项：在实现简单选择排序时需要注意数组越界的问题，以及在处理大数据量时需要考虑算法的时间 复杂度和空间复杂度。
数组元素必须为整数 数组元素必须为正整数 数组元素必须按升序排列 数组元素不能重复
减少比较次数
限制：对于大型数据集，简单选择排序算法的性能较差，有更高效的排序算法可供选择，如快速排序、归并排序 等。
场景：简单选择排序算法适用于对稳定性要求不高的场景，如对少量数据进行快速排序、对小型数据集进行初步 排序等。
python中对列表元素大小排序（冒泡排序法和选择排序法）
python中对列表元素⼤⼩排序（冒泡排序法和选择排序法）前⾔：排序(Sorting) 是计算机程序设计中的⼀种重要操作，它的功能是将⼀个数据元素（或记录）的任意序列，重新排列成⼀个关键字有序的序列。
本⽂主要讲述python中经常⽤的两种排序算法，选择排序法和冒泡排序法及其区别。
通过对列表⾥的元素⼤⼩排序进⾏阐述。
⼀，选择排序法从第⼀个位置开始⽐较，找出最⼩的，和第⼀个位置互换，开始下⼀轮。
lt = [3, 5, 2, 1, 8, 4]#求出lt的长度n = len(lt)#外层循环确定⽐较的轮数，x是下标，lt[x]在外层循环中代表lt中所有元素for x in range(n-1):#内层循环开始⽐较for y in range(x+1,n):#lt[x]在for y 循环中是代表特定的元素，lt [y]代表任意⼀个lt任意⼀个元素。
if lt[x]>lt[y]:#让lt[x]和lt列表中每⼀个元素⽐较，找出⼩的lt[x],lt[y]=lt[y],lt[x]print(lt)⼆，冒泡排序法排序从左到右，数组中相邻的两个元素进⾏⽐较，将较⼤的放到后⾯。
lt = [3, 5, 2, 1, 8, 4]n= len(lt)for x in range(n-1):for y in range(n-1-x):if lt[y]>lt[y+1]:lt[y],lt[y+1]=lt[y+1],lt[y]print(lt)选择排序法和冒泡排序法的区别:冒泡排序是⽐较相邻位置的两个数，⽽选择排序是按顺序⽐较，找最⼤值或者最⼩值；冒泡排序每⼀轮⽐较后，位置不对都需要换位置，选择排序每⼀轮⽐较都只需要换⼀次位置；冒泡排序是通过数去找位置，选择排序是给定位置去找数；。
常用的排序算法及其适用场景
常⽤的排序算法及其适⽤场景⼀、排序的具体应⽤1、淘宝商品价格排序：商品按价格⾼低排序后显⽰;租房时看价格，从低到⾼；2、微博热搜排⾏榜：排序后，最⾼的⼗个关键字，上热搜3、QQ好友列表：按照好友名字的排序（涉及字符排序）4、超星移动图书馆热书榜：排序后，最⾼的⼗本书为热书⼆、选择排序——取商品的价格1.升序public class choose {public static void main(String[] args) {// double[] arr = {50.60,65.344,42.9,94,12,33,61};//float的数后⾯必须加f//选择排序/*思路：1.拿第⼀个元素与后⾯的⽐较，把⼩的放在第⼀个,进⾏位置互换2.拿第⼆个元素与后⾯的⽐较，把⼩的放在第⼆个,进⾏位置互换......*///1.升序//取商品的价格float[] arr2 = {50,61.10f,72.9f,80,77.777f,45.31f};//控制排序的次数nfor (int i = 0; i <arr2.length -1 ; i++) {//取第⼀个数为最⼩的数的位置int min= i;//寻找最⼩的数for(int j = i+1 ;j <arr2.length ;j++){if (arr2[min] > arr2[j]){//记录⽬前能找到的最⼩值元素的下标min = j;}}//将找到的最⼩值和i位置所在的值进⾏交换if (i != min){float temp = arr2[i];arr2[i] = arr2[min];arr2[min] = temp;}}//第 i轮排序的结果为System.out.print("排序后的结果为:"+ Arrays.toString(arr2));}}2.降序//取商品的价格float[] arr2 = {50,61.10f,72.9f,80,77.777f,45.31f};//控制排序的次数nfor (int i = 0; i <arr2.length -1 ; i++) {//取第⼀个数为最⼩的数的位置int min= i;//寻找最⼩的数for(int j = i+1 ;j <arr2.length ;j++){if (arr2[min] < arr2[j]){//记录⽬前能找到的最⼩值元素的下标min = j;}}//将找到的最⼩值和i位置所在的值进⾏交换if (i != min){float temp = arr2[i];arr2[i] = arr2[min];arr2[min] = temp;}}//第 i轮排序的结果为System.out.print("排序后的结果为:"+ Arrays.toString(arr2));}}三、冒泡排序——给同学们按⾝⾼排座位public class PaiXu {public static void main(String[] args) {//冒泡排序——给同学们按⾝⾼排座位/*思路：1.第⼀个与第⼆个⽐，⼤的放第⼆个2.第⼆个与第三个⽐，⼤的放第三个*/int[] arr = {178, 162,174,166,184,171,175, 177,169};//控制循环次数nfor (int i = 0;i < arr.length;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("排序后：");//数组输出System.out.println(Arrays.toString(arr));}}四、插⼊排序1.基本排序⽅法public class ChaRu {public static void main(String[] args) {//插⼊排序/*1.第⼀个数字默认已经排序2.取第⼆个数与第⼀个⽐较，然后排序3.取第三个数与前两个数⽐较，然后⽐较......*/int[] arr = {345,78,98,67,56,77};int j;//第⼀层循环：控制⽐较次数for (int i = 1; i < arr.length; i++) {int temp = arr[i];j = i;while (j > 0 && temp < arr[j - 1]) {arr[j] = arr[j - 1]; //向后挪动j--;}//存在更⼩的数，插⼊arr[j] = temp;}System.out.println(Arrays.toString(arr));}}2.给中⽂姓名排序public class NameSort {public static void main(String[] args) {String[] a = {"王五", "李四", "张三", "刘六", "⽩⼀", "苦⼆"};getSortOfChinese(a);/*for (int i = 0; i < a.length; i++) {System.out.println(a[i]);}*/System.out.println(Arrays.toString(a));}//定义排序函数public static String[] getSortOfChinese(String[] a) {// Collator 类是⽤来执⾏区分语⾔环境这⾥使⽤CHINAComparator cmp = Collator.getInstance(java.util.Locale.CHINA); // JDKz⾃带对数组进⾏排序。
算法实例选择排序法ppt课件
总共比较数据1次，交换数据1次。
显然，通过上述3遍处理，数组d中最小、第2 小、第3小的数据已经分别存储在数组元素d(1)、 d(2)、d(3)中，即数组元素d(1)到d(3)变为有序， 而剩下的d(4)中的数据自然是数组中的最大数据 。因此，通过3遍这样的处理，整个数组内的数据 将是有序的。
第3遍
第4遍
60 58 55 48 43 46
第5遍
60 58 55 48 46 43
A.60、58、48、46、43、55 C.60、58、55、46、43、48
B.60、43、48、46、58、55 D.60、58、55、48、46、43
5. 已知算法1与算法2都是排序算法，可能是冒泡排序或者选择排
1
7
2
9
3
13
4
18
5
55
6
43
7
43
第五趟：从3个元素中选出最小者，将其换入位置5，过程 为：令min_elem表示最小元素（初值为位置5的元素），k 为最小元素的位置序号（初值为5），逐一比较，找出最 小元素及其位置
1
7
2
9
3
13
4
18
5
55
6
43
7
43
位置6的元素最小 交换
1
7
2
9
3
13
4
4个元素共需进行3遍加工处理，总的比较次 数为3＋2＋1＝6次，而总计交换次数每一遍一次 ，共计只有3次。
对于n个元素的数组，用选择算法进行排序时 ，比较次数与冒泡算法相同，但交换的次数比冒 泡排序要少，因此它具有较高的效率。
选择排序简单例题
选择排序简单例题含解答共5道问题1：使用选择排序对以下数组进行排序：[64, 25, 12, 22, 11]解答1：```plaintext初始数组：[64, 25, 12, 22, 11]第1步：找到最小元素11，并与第一个元素64交换位置[11, 25, 12, 22, 64]第2步：在剩余元素中找到最小元素12，并与第二个元素25交换位置[11, 12, 25, 22, 64]第3步：在剩余元素中找到最小元素22，并与第三个元素25交换位置[11, 12, 22, 25, 64]第4步：在剩余元素中找到最小元素25，并与第四个元素25交换位置（实际上不需要交换）[11, 12, 22, 25, 64]最终排序结果：[11, 12, 22, 25, 64]```问题2：使用选择排序对以下数组进行排序：[38, 27, 43, 3, 9, 82, 10]解答2：```plaintext初始数组：[38, 27, 43, 3, 9, 82, 10]第1步：找到最小元素3，并与第一个元素38交换位置[3, 27, 43, 38, 9, 82, 10]第2步：在剩余元素中找到最小元素9，并与第二个元素27交换位置[3, 9, 43, 38, 27, 82, 10]第3步：在剩余元素中找到最小元素10，并与第三个元素43交换位置[3, 9, 10, 38, 27, 82, 43]第4步：在剩余元素中找到最小元素27，并与第四个元素38交换位置[3, 9, 10, 27, 38, 82, 43]第5步：在剩余元素中找到最小元素38，并与第五个元素38交换位置（实际上不需要交换）[3, 9, 10, 27, 38, 82, 43]第6步：在剩余元素中找到最小元素43，并与第六个元素82交换位置[3, 9, 10, 27, 38, 43, 82]最终排序结果：[3, 9, 10, 27, 38, 43, 82]```问题3：使用选择排序对以下数组进行排序：[5, 8, 2, 1, 6, 3]解答3：```plaintext初始数组：[5, 8, 2, 1, 6, 3]第1步：找到最小元素1，并与第一个元素5交换位置[1, 8, 2, 5, 6, 3]第2步：在剩余元素中找到最小元素2，并与第二个元素8交换位置[1, 2, 8, 5, 6, 3]第3步：在剩余元素中找到最小元素3，并与第三个元素8交换位置[1, 2, 3, 5, 6, 8]第4步：在剩余元素中找到最小元素5，并与第四个元素5交换位置（实际上不需要交换）[1, 2, 3, 5, 6, 8]第5步：在剩余元素中找到最小元素6，并与第五个元素6交换位置（实际上不需要交换）[1, 2, 3, 5, 6, 8]最终排序结果：[1, 2, 3, 5, 6, 8]```问题4：使用选择排序对以下数组进行排序：[20, 15, 10, 5, 25]解答4：```plaintext初始数组：[20, 15, 10, 5, 25]第1步：找到最小元素5，并与第一个元素20交换位置[5, 15, 10, 20, 25]第2步：在剩余元素中找到最小元素10，并与第二个元素15交换位置[5, 10, 15, 20, 25]第3步：在剩余元素中找到最小元素15，并与第三个元素15交换位置（实际上不需要交换）[5, 10, 15, 20, 25]第4步：在剩余元素中找到最小元素20，并与第四个元素20交换位置（实际上不需要交换）[5, 10, 15, 20, 25]最终排序结果：[5, 10, 15, 20, 25]```问题5：使用选择排序对以下数组进行排序：[12, 11, 13, 5, 6]解答5：```plaintext初始数组：[12, 11, 13, 5, 6]第1步：找到最小元素5，并与第一个元素12交换位置[5, 11, 13, 12, 6]第2步：在剩余元素中找到最小元素6，并与第二个元素11交换位置[5, 6, 13, 12, 11]第3步：在剩余元素中找到最小元素11，并与第三个元素13交换位置[5, 6, 11, 12, 13]第4步：在剩余元素中找到最小元素12，并与第四个元素12交换位置（实际上不需要交换）[5, 6, 11, 12, 13]最终排序结果：[5, 6, 11, 12, 13]```。
选择排序例题
选择排序（Selection Sort）是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
以下是一个选择排序的例题：
假设我们有一个整数数组 `arr`，它包含一些未排序的数字。
我们的任务是使用选择排序算法对它进行排序。
```python
def selection_sort(arr):
# 遍历所有数组元素
for i in range(len(arr)):
# 找到未排序部分中的最小元素
min_index = i
for j in range(i+1, len(arr)):
if arr[j] < arr[min_index]:
min_index = j
# 将找到的最小元素与第一个未排序的元素交换
arr[i], arr[min_index] = arr[min_index], arr[i] return arr
# 示例数组
arr = [64, 25, 12, 22, 11]
# 对数组进行排序
sorted_arr = selection_sort(arr)
# 输出排序后的数组
print(sorted_arr)
```
当你运行上述代码时，它会输出以下排序后的数组：
```csharp
[11, 12, 22, 25, 64]
```
这个算法的时间复杂度是 O(n^2)，其中 n 是数组的长度。
因此，对于大型数据集，选择排序可能不是最有效的排序算法。
然而，由于其简单性和直观性，它经常在教学和演示中使用。
c语言选择排序算法
c语言选择排序算法摘要：一、选择排序算法简介1.选择排序算法的概念2.选择排序算法的原理二、选择排序算法的实现1.基本思想2.具体实现步骤3.代码展示三、选择排序算法的特点及应用场景1.特点2.应用场景四、选择排序算法的优缺点分析1.优点2.缺点五、总结正文：一、选择排序算法简介选择排序算法是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
二、选择排序算法的实现1.基本思想选择排序算法的基本思想是在未排序序列中找到最小值，将其放到已排序序列的末尾。
以此类推，直到全部待排序的数据元素排完。
2.具体实现步骤（1）首先从第一个元素开始，找到未排序序列中最小的元素，存放在序列的起始位置。
（2）然后从第二个元素开始，在未排序序列中继续寻找最小元素，将其放到已排序序列的末尾。
（3）重复以上过程，直到全部待排序的数据元素排完。
3.代码展示```c#include <stdio.h>void selectionSort(int arr[], int n) {int i, j, minIndex;for (i = 0; i < n-1; i++) {minIndex = i;for (j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}if (minIndex != i) {int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}}}int main() {int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr)/sizeof(arr[0]);selectionSort(arr, n);printf("Sorted array is:");for (int i=0; i < n; i++) {printf("%d ", arr[i]);}printf("");return 0;}```三、选择排序算法的特点及应用场景1.特点选择排序算法的特点是简单直观，易于理解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
A.60、58、48、46、43、55 C.60、58、55、46、43、48
共比较数据2次，交换数据1次。 第3遍：寻找从d(3)到d(4)范围内的最小数据d(k)，即k＝4，将d(3)与d(k)互换数据：
总共比较数据1次，交换数据1次。
显然，通过上述3遍处理，数组d中最小、第2小、第3小的数据已经分别存储在数 组元素d(1)、d(2)、d(3)中，即数组元素d(1)到d(3)变为有序，而剩下的d(4)中的数据自 然是数组中的最大数据。因此，通过3遍这样的处理，整个数组内的数据将是有序的。 4个元素共需进行3遍加工处理，总的比较次数为3＋2＋1＝6次，而总计交换次数 每一遍一次，共计只有3次。 对于n个元素的数组，用选择算法进行排序时，比较次数与冒泡算法相同，但交 换的次数比冒泡排序要少，因此它具有较高的效率。 2．选择排序算法的程序实现 选择排序的程序同样采用双重For循环嵌套来实现，外循环来控制是第几遍加工， 内循环用来控制数组内进行排序元素的下标变化范围。在每一遍加工结束，都需要用一 个变量来存储这一遍加工中所找出的最小(或最大)的数据在数组内的下标。 现有n个数据，分别存放在数组变量a(1 To n)当中，采用选择排序算法程序实现其 从小到大的程序结构如下： 实现该算法的程序段如下： For i＝1 To n－1 k＝i For j＝i＋1 to n If a(j)<a(k) Then k＝j Next j If i<>k Then t＝a(i)：a(i)＝a(k)：a(k)＝t End If Next i
数组元素 值
d(1) 105
d(2) 12排序法按升序进行排序的过程，从数组第一个元素开始起：第1遍：寻找从 d(1)到d(4)范围内的最小数据d(k)，即k＝4，将d(1)与d(k)互换数据：
共比较数据3次，交换数据1次。
第2遍：寻找从d(2)到d(4)范围内的最小数据d(k)，即k＝3，将d(2)与d(k)互换数据：
上虞区小越中学信息技术组
【例1】在2015年秋季学校运动会上，男生第一组6位选手的110米栏成绩(单位：秒) 分别是“18.4、17.3、16.9、18.8、18.1、16.7”，若使用选择排序法将该组的成绩按第 一名、第二名、第三名……的顺序排序，则第一次交换数据后的顺序是 ( ) A.18.8 18.4 17.3 16.9 18.1 16.7 B.16.7 17.3 16.9 18.8 18.1 18.4 C.18.8 17.3 16.9 18.4 18.1 16.7 D.16.7 18.4 17.3 16.9 18.8 18.1
【例2】(浙江省2012年9月高考)实现某排序算法的部分VB程序如下： For i = 1 To 6 k=i For j = i + 1 To 7 If a(j) ＜ a(k) Then k = j Next j If i ＜＞ k Then t = a(i): a(i) = a(k): a(k) = t End If Next i 在排序过程中，经过某一遍排序“加工”后，数组元素a(1)到a(7)的数据依次为“10，41， 75，12，63，11，85”。则下一遍排序“加工”后数组元素a(1)到a(7)的数据依次是（ ） A. 10, 11, 41, 75, 12, 63, 85 B. 10, 11, 75, 12, 63, 41, 85 C. 10, 11, 12, 75, 63, 41, 85 D. 10, 11, 12, 41, 63, 75, 85
《算法应用开发工程师》 职业概述：如果要问程序设计的灵魂是什么，相信很多人都会回答是算法，一个优秀的算法工程师往往可以带来 生产力的巨大提升。当你为实现某一功能而冥思苦想、费尽周折时，可能你需要的只是另一个精辟而又简洁的算 法。 工作内容：设计和优化应用算法，并协助完成应用软件方案设计及算法设计； 独立完成数学建模及算法设计； 编写相关技术文档。 职业要求：教育培训： 应用数学、计算机等相关专业本科以上学历。 工作经验：算法开发人员重在很强的逻辑思维能力。并且需要熟练掌握数学建模、应用算法的设计和优化理论； 精通C/C++ 或其他一种编程语言；熟悉数据库的接口技术。 薪资行情：一般月薪范围4500～10000元。全国平均薪酬水平达到6000元/月，北京平均薪酬水平达到6700元/月 左右，上海平均8500元/月，广州7500元/月。随着工作经验的积累增加，薪酬待遇的提高幅度会很大。 职业发展路径：国内算法应用开发工程师人才缺乏，需求相对较大。此职位专业技术性很强，对数学、算法及编 程能力有很高的要求。经过一段时间的工作经验的积累后，可发展成为高级软件工程师、需求工程师，但需要具 有丰富的软件开发经验和相关工作的技术背景。如果想成为技术经理、项目经理，则还需要具有较强的管理和组 织等方面的能力。
算法实例
选择排序法
小越中学信息技术组
1．选择排序算法的概念 选择排序算法是对冒泡排序算法的改进。这种方法是对参加排序数组的所有元 素中找出最小(或最大)数据的元素，使它与第一个元素中数据相互交换位置。然后在 余下的元素中找出最小(或最大)的数据的元素，与第二个元素中的数据交换位置。以 此类推，直到所有元素成为一个有序的序列。 某数组d共有4个元素构成，每个元素的值如下表所示：
3．某校通过政府招投标中心采购一套多媒体教学设备，有5家单 位参加竞标，竞标价分别为18万、17万、23万、15万、16万 元人民币。若采用选择排序算法对标价从大到小排序，需要 进行数据互换的次数是 ( B ) A．1 B．3 C．4 D．5 4．圣诞节即将来临，某商场欲对仓库某货号商品进行补仓以应对 即将举办的促销活动。6家供货商给出的报价分别为48、43、 60、46、58、55，若采用选择排序算法对其进行从大到小排序 ，则第三遍的排序结果是 ( C )
本节的学习要求掌握选择排序的基本思想，能根据 选择排序的思想来进行选择排序的操作。掌握用程序来 实现选择排序的算法，能根据生活中的实际要求编写选 排排序的程序，从而进一步熟悉多重循环程序的编写。 考查方式为选择题与填空题。
1. 用选择排序算法对一组学生的身高数据进行升序排序，已 知第一遍排序结束后的数据序列为166、169、177、175、 172，则下列选项中可能是原始数据序列的是 ( B ) A．175、177、169、166、172 B．177、169、166、175、172 C．166、177、169、175、172 D．166、169、172、175、177 2．有6位裁判为运动员评分，给出的分数分别为48、45、 63、46、59、57。采用选择排序算法对其进行排序，若 完成第一遍时的结果为：63、45、48、46、59、57，则 完成第二遍时的结果是 ( D ) A．63、45、48、46、59、57 B．63、59、57、48、45、46 C．63、59、57、46、45、48 D．63、59、48、46、45、57
B.60、43、48、46、58、55 D.60、58、55、48、46、43
5. 已知算法1与算法2都是排序算法，可能是冒泡排序或者选择排 序，下面的表格反应的是在不同量的数据下，排序时进行数据 交换的次数，分析算法1与算法2最有可能的排序算法分别是 ( C )
排序的数据个数 5 11 22 53 84 105 算法1的交换次数 7 41 83 748 1821 2910 算法2的交换次数 3 8 13 52 71 94
A.冒泡排序 冒泡排序 C．冒泡排序 选择排序
B．选择排序 选择排序 D．选择排序 冒泡排序
6. 下列关于排序的说法，错误的是 ( C ) A．相对而言，选择排序算法的效率比冒泡排序算法高 B．冒泡排序算法和选择排序算法的都需要用到双循环结构 C．对于n个无序数据，不管是冒泡排序还是选择排序，都要经过n－1遍加工 D．冒泡排序算法的程序实现一般要用到数组变量k，而选择排序则不需要
练习
1.选择排序的基本思想是在所有的记录中选出最小(大)的数据，把它与第一个数据交换， 然后在其余的记录中再选出最小(大)的数据与第二个数据交换，依此类推，直至所有 数据排序完成。有一组数据，顺序是“4、6、2、8、9”，用选择排序法将这组数据从 大到小排序，第二遍交换数据后的顺序是 （ ） A.9、4、6、2、8 B.9、8、4、2、6 C.9、8、2、4、6 D.9、8、2、6、4
当外循环变量i取1时，为第1遍加工，k＝1，先假设第1个数据元素为最小值 ，内循环从第2个数开始比较，如果a(2)小于a(1)，则将a(2)的下标赋值给k，否则k 值不变，这个方法目的是保证k是本遍加工最小数据元素的下标。这样，内循环一 次完成之后，判断k是不是a(1)的下标1，如果不是，则把a(k)与a(1)的数据进行交 换，否则就不进行交换。这样，第1遍加工后，就能把最小的数据存放在a(1)中。 当外层循环变量i取2时，为第2遍加工，找出a(2)到a(n)之间的最小数，记录好它的 下标k，把最小的数据放到a(2)中。这样，每遍加工，都能找出最小数的下标k， 比较是不是i，如果不是，就将a(k)与a(i)交换。经过n－1遍之后，就能实现从小到 大的排序。 选择排序的关键在于最小值变量k的值在不断的发生变化，而每一遍加工，最多 只交换一次数据，所以排序的效率比冒泡排序要高。
7. 小明编写了一个统计数组元素a(l)到a(n)中的“升序段”个 数s(如图所示的数据序列，其 “升序段”的个数等于3)的 VB程序。 部分程序代码如下： k ＝ 0 s ＝ 0 For i ＝ 2 To n If a(i) > a(i － 1) Then Else k ＝ 0 End If If k ＝ 1 Then s ＝ s ＋ 1 Next i Textl.Text ＝ Str(s) 方框中的正确语句是 A．k＝k－1 B．K＝1 C．K＝－1