• 选择排序
    • 基本思想
    • 步骤
    • By C++
    • By Golang
    • 排序过程

    选择排序

    基本思想

    • 每次从未排序的序列中选择最小的数放置在该未排序序列的第一个
    • 不断循环,直到排序完成

    步骤

    • 第一层循环:i=0; i < len(list)-1; i++
    • 第二层循环:j := i + 1; j < len(list); j++
    • 寻找未排序序列中最小的数: if list[j] < list[minIndex] { minIndex = j }
    • 将最小的数与放置到当前未排序序列的第一个: list[i], list[minIndex] = list[minIndex], list[i]

    By C++

    1. #include <stdio.h>
    2. #define MaxSize 100
    3. typedef int KeyType; /*关键字类型*/
    4. typedef char ElemType[10]; /*其他数据项类型*/
    5. typedef struct
    6. {
    7. KeyType key; /*关键字域*/
    8. ElemType data; /*其他数据域*/
    9. } LineList; /*线性表元素类型*/
    10. void SelectSort(LineList R[],int n)
    11. {
    12. int i,j,k;
    13. LineList tmp;
    14. for (i=0;i<n-1;i++)
    15. {
    16. k=i;
    17. for (j=i+1;j<n;j++)
    18. if (R[j].key<R[k].key)
    19. k=j; /*用k指出每趟在无序区段的最小元素*/
    20. tmp=R[i]; /*将R[k]与R[i]交换*/
    21. R[i]=R[k];
    22. R[k]=tmp;
    23. }
    24. }
    25. void main()
    26. {
    27. LineList R[MaxSize];
    28. KeyType a[]={75,87,68,92,88,61,77,96,80,72};
    29. int n=10,i;
    30. for (i=0;i<n;i++)
    31. R[i].key=a[i];
    32. printf("排序前:");
    33. for (i=0;i<n;i++)
    34. printf("%3d",R[i].key);
    35. printf("\n");
    36. SelectSort(R,n);
    37. printf("排序后:");
    38. for (i=0;i<n;i++)
    39. printf("%3d",R[i].key);
    40. printf("\n");
    41. }

    By Golang

    1. package main
    2. import (
    3. "fmt"
    4. )
    5. // 选择排序
    6. func selectSort(list []int) []int {
    7. var minIndex int
    8. for i := 0; i < len(list)-1; i++ {
    9. minIndex = i
    10. for j := i + 1; j < len(list); j++ {
    11. if list[j] < list[minIndex] { // 寻找未排序序列中最小的数
    12. minIndex = j
    13. }
    14. }
    15. list[i], list[minIndex] = list[minIndex], list[i] // 将当前数与最小的数交换位置
    16. fmt.Println("第", i+1, "趟:", list) // 打印每趟的序列
    17. }
    18. return list
    19. }
    20. func main() {
    21. list := []int{75, 87, 68, 92, 88, 61, 77, 96, 80, 72}
    22. fmt.Println("初始序列:", list)
    23. result := selectSort(list)
    24. fmt.Println("最终结果:", result)
    25. }

    排序过程

    1. 初始序列: [75 87 68 92 88 61 77 96 80 72]
    2. 1 趟: [61 87 68 92 88 75 77 96 80 72]
    3. 2 趟: [61 68 87 92 88 75 77 96 80 72]
    4. 3 趟: [61 68 72 92 88 75 77 96 80 87]
    5. 4 趟: [61 68 72 75 88 92 77 96 80 87]
    6. 5 趟: [61 68 72 75 77 92 88 96 80 87]
    7. 6 趟: [61 68 72 75 77 80 88 96 92 87]
    8. 7 趟: [61 68 72 75 77 80 87 96 92 88]
    9. 8 趟: [61 68 72 75 77 80 87 88 92 96]
    10. 9 趟: [61 68 72 75 77 80 87 88 92 96]
    11. 最终结果: [61 68 72 75 77 80 87 88 92 96]