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

杨利霞

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

% N$ t5 ~* U5 n. m选择排序概念
' K- n, q# Q8 N% x        选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 --form baike

思想
*     每次从待排序的数据元素中选出最小或最大的一个元素，存放在序列的起始或末尾位置
9 h* z$ G0 c( R5 J* n*     长度为n的数组一共需要进行n-1趟排序，每趟排序会进行一次值的交换；
*     当进行下一次排序时，范围缩小1
: s4 s+ R# z3 z  Y- s, N
7 r7 Q7 ]5 u* O代码实现
package com.lll.datastructure.sort;

import java.util.Arrays;

# E6 j! p7 e9 `- B0 P4 j, I/**
+ L# E. P( V1 \  @ *
* @ClassName: SelectionSort
& r+ x- |6 u5 C* @Description: 选择排序
* @Author: liulianglin
* @DateTime 2022年9月7日 上午9:12:13
9 D. A1 e# `3 T9 ~5 E5 X*
  @, y- e% x. O' H; y1 G$ }* 选择排序思想：
6 n2 J( X+ \5 T& o*         每次从待排序的数据元素中选出最小或最大的一个元素，存放在序列的起始或末尾位置
*         长度为n的数组一共需要进行n-1趟排序，每趟排序会进行一次值的交换；
7 m+ f, A' d( k        当进行下一次排序时，范围缩小1
*/
2 s& i  C# b5 i. rpublic class SelectionSort {
        public static void main(String[] args) {
) ~1 E6 e; l4 T                // 待排序数据
2 a5 X' |; J$ g0 `- U                int[] arr = {1,3,2,4,7,54,11,34,9};
               
8 {  r) G/ n% X1 ~1 x! l3 F6 ?                // 记录当前趟数查找到的最大值的数组下标
, N0 u2 n/ P9 u! w6 C                int max;
               
                // 交换变量
                int temp;
               
; u4 q# }' e- R                System.out.println("排序前：" + Arrays.toString(arr));

, B8 c2 z1 d' ]: J. O                // 外层控制循环需要排序的趟数
                for(int i = 0; i < arr.length - 1; i++) {
0 N0 z  f1 Y" L, `, L( \. p                        // 每一趟都默认数组第一个元素为最大值
/ N- z( s+ d4 \* F, Z4 \                        max = 0;
3 B: S- `0 ]3 f* C" o                       
                        // 内循环控制遍历数组的个数（每趟减1），并得到最大数的下标
2 }5 ~8 p4 j( P( w. I                        for (int j = 0; j < arr.length - i; j++) {
- `; P4 X/ n6 l# {                                if (arr[j] > arr[max]) {
                                        max = j;
7 ~2 k$ O/ D, k9 {# e; U  o/ `2 O                                }
9 K# ^7 F& k0 s2 e! Q* V% W                        }
                       
                        // 将交换变量设置为最大值, 将最大值暂存一下
                        temp = arr[max];
                        // 将当前最大值设置为当前未排序序列的最后一个元素值
% j- j/ o& c; z, y: }& J; v- z. R                        arr[max] = arr[arr.length - 1 - i];
                        // 将刚才缓存的最大值，设置为当前未排序队列的最后一个元素，完成交换
                        arr[arr.length - 1 - i] = temp;
5 G+ M4 [7 d7 e; ^4 K7 g& m                }
               
                System.out.println("排序后：" + Arrays.toString(arr));
) [/ u2 Q% J9 y& P& M. x3 n8 `        }
8 }  k1 W2 Q  v; O1 b}
+ U$ Q) Q% Z7 x/ S- ?" O
2 d6 b6 y( O4 E) l) D. h% {关键步骤：

* m( t9 _: s1 c" B2 R% J1. 首先定义两个变量：分别表示最大值标 和 交换变量；

1 T! O9 q7 w! @3 u7 I7 y" \2. 通过外层for循环，控制排序的趟数；
/ W' E* A8 i# y& C. I+ W) E
/ z1 q' e$ S  n4 U0 Q3. 通过内循环控制每趟需要遍历数组的次数，每趟会较上一趟减1，每次会得到最大值的下标。再下一趟外循环会将这个下标重新置为0；
  K: [, T3 o$ c. X- G. y6 Y' ^$ P
4. 每趟找到最大值后，将交换变量设置为最大值，目的是将最大值进行一个暂存；
8 s8 q+ T; h3 ]6 K
3 {3 l: `  I% B. H9 y5.然后将最大值设置为当前未排序序列的最后一个元素；
# u! h; H% T' k
6.最后将第4步缓存的最大值，设置为的当前未排序序列的最后一个元素

7.至此完成数据交换，继续进行步骤2，直到数据数据有序。
9 @, S4 F; i3 p+ b
执行结果
# E5 a: [/ K3 C& v
+ R8 v  {0 l: {, E5 f————————————————
* B, ?# V' |) c$ v6 L版权声明：本文为CSDN博主「大林子先森」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+ B' F+ i+ b/ t$ A  M! J/ k  J4 U原文链接：https://blog.csdn.net/liulianglin/article/details/126741594


' T0 j" `$ n$ K! [2 Q