排序算法--选择排序（Java实现）

杨利霞

排序算法--选择排序（Java实现）
! w0 }  S. W$ c& U1 H7 ~& \" g- `% J0 t
+ T  T% }# s: N7 G) V4 }2 L$ U选择排序概念
3 f& M0 F! Y2 u  Y* h# U: `: B* q        选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 --form baike

" V) O0 K' B: W/ x+ K, H/ J! Y3 O% `思想
*     每次从待排序的数据元素中选出最小或最大的一个元素，存放在序列的起始或末尾位置
*     长度为n的数组一共需要进行n-1趟排序，每趟排序会进行一次值的交换；
1 j2 w# T7 f  x5 ]* q7 q" u*     当进行下一次排序时，范围缩小1
) z+ s8 k: [2 B) w; u; P* O0 e
代码实现
$ i) |) k! L+ K7 ?4 @8 R" ppackage com.lll.datastructure.sort;

import java.util.Arrays;
$ T6 w6 I. b/ U; ?9 E
/**
*
* @ClassName: SelectionSort
* @Description: 选择排序
3 t5 x/ |. ]) l8 y2 }7 f: R* @Author: liulianglin
/ X% @5 E. W% H( c( w* @DateTime 2022年9月7日 上午9:12:13
' V/ E  d8 W9 k: D. O3 k+ C1 m9 [*
- K. Z- h& U! B+ \! _/ q& T* 选择排序思想：
*         每次从待排序的数据元素中选出最小或最大的一个元素，存放在序列的起始或末尾位置
*         长度为n的数组一共需要进行n-1趟排序，每趟排序会进行一次值的交换；
0 a& R0 V' z! z( Q: x# [; Z        当进行下一次排序时，范围缩小1
( j; g* j- ]; q# ?* j+ Y- v */
public class SelectionSort {
        public static void main(String[] args) {
. R: F$ U' A) r5 ~  J( i  K+ ]* E                // 待排序数据
                int[] arr = {1,3,2,4,7,54,11,34,9};
               
                // 记录当前趟数查找到的最大值的数组下标
                int max;
               
                // 交换变量
& x0 |" W# N9 T$ d+ b0 p                int temp;
1 E+ W( P2 h1 M4 p8 q: W               
                System.out.println("排序前：" + Arrays.toString(arr));
1 Y8 M/ Y& Y$ ?3 `
                // 外层控制循环需要排序的趟数
  `3 @0 y+ b0 T- _) X6 x                for(int i = 0; i < arr.length - 1; i++) {
                        // 每一趟都默认数组第一个元素为最大值
4 r( u$ C$ G& e! L$ v+ X+ q                        max = 0;
: J  o- T3 p% p$ p) X+ c) T6 d                       
                        // 内循环控制遍历数组的个数（每趟减1），并得到最大数的下标
                        for (int j = 0; j < arr.length - i; j++) {
                                if (arr[j] > arr[max]) {
* U1 E9 Z- {5 T6 _                                        max = j;
                                }
                        }
                       
4 V) O- x+ v) E  b" B                        // 将交换变量设置为最大值, 将最大值暂存一下
, i" a2 P% Z: k% M                        temp = arr[max];
0 v/ D8 Z- u4 D5 n8 e                        // 将当前最大值设置为当前未排序序列的最后一个元素值
                        arr[max] = arr[arr.length - 1 - i];
4 [1 J  E% M* V$ B                        // 将刚才缓存的最大值，设置为当前未排序队列的最后一个元素，完成交换
                        arr[arr.length - 1 - i] = temp;
                }
               
$ P, E2 V) L. E1 h1 L9 d                System.out.println("排序后：" + Arrays.toString(arr));
        }
}

关键步骤：
8 Y6 _( |6 {, q! |7 `; Q7 @
1. 首先定义两个变量：分别表示最大值标 和 交换变量；
! ~; _) e/ Y9 q- e7 [; W
' Q6 [  P) B9 z- D1 v2. 通过外层for循环，控制排序的趟数；

6 I! Y3 G) @# o" N3. 通过内循环控制每趟需要遍历数组的次数，每趟会较上一趟减1，每次会得到最大值的下标。再下一趟外循环会将这个下标重新置为0；
% D( \) N$ T+ t/ P4 p2 n3 ]7 H
4. 每趟找到最大值后，将交换变量设置为最大值，目的是将最大值进行一个暂存；

5.然后将最大值设置为当前未排序序列的最后一个元素；

6.最后将第4步缓存的最大值，设置为的当前未排序序列的最后一个元素

7.至此完成数据交换，继续进行步骤2，直到数据数据有序。
% m& d) O  v6 w9 \8 x; o
执行结果

4 F; j* P" K& \! P( v————————————————
版权声明：本文为CSDN博主「大林子先森」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liulianglin/article/details/126741594
- u$ G" v' j$ r
) o8 J0 q8 ?3 E" |
9 O. t# |" S& V# e& v+ j6 t- J/ u