数学建模社区-数学中国

标题: 排序算法--选择排序(Java实现) [打印本页]

作者: 杨利霞    时间: 2022-9-8 10:05
标题: 排序算法--选择排序(Java实现)
排序算法--选择排序(Java实现)
' P1 |) H, q- i. Y- q4 k
, [; `2 Z- {# ]& a% A% ]1 @4 ~选择排序概念: t* s& e" I* N- b3 Z  N
        选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 --form baike8 F7 K2 g9 {. B

. a7 J" z& f2 f" n7 g( l思想; E) \. X6 G; Y$ Z; B
*     每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置
$ D0 A- e" s/ o+ S7 y+ B*     长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;* O0 J- I, L8 {( p( r+ Q
*     当进行下一次排序时,范围缩小1
. n6 @3 I2 ?2 Y& Y: t, D8 L; }* |7 j& X- J# B- R! f% g
代码实现) S6 {8 W1 _* q! ^/ U: g8 e
package com.lll.datastructure.sort;- e1 @. e! U0 Q% ]/ b* j' |3 y1 g

; s6 N+ w" H- e; a  u& F4 zimport java.util.Arrays;, z# @1 |2 C7 m

* x& N' l( t9 J4 Y/**
/ c. _/ C( [: w* B *
4 u: E% B# @  K4 a- z/ _$ H* @ClassName: SelectionSort
; a, n0 M7 r- j/ u$ |; ^1 `4 Y$ `* H* @Description: 选择排序
. F, O; f+ z2 E+ G, T' ?* @Author: liulianglin
; d1 x( J3 @! z; B* @DateTime 2022年9月7日 上午9:12:13
% g- n1 ^) j# K; U- n* ! R- I9 o; `* H
* 选择排序思想:
2 I8 I+ E- J! b  C( c/ c* o1 m*         每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置
$ B* ]+ Z/ Y* d  @' \9 A# U' H3 V$ _- d*         长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;
( t( v0 q4 O, c" R$ `0 m        当进行下一次排序时,范围缩小1
' U! g! `3 P$ T9 h */' [# b  x- `. D" F
public class SelectionSort {+ H  [& o1 d6 [
        public static void main(String[] args) {
, R2 t3 {& j+ a' D$ f) D9 }$ ?- ]4 n                // 待排序数据
( Q# k) K3 D1 A9 I4 t                int[] arr = {1,3,2,4,7,54,11,34,9}; ) m, z5 H3 ]1 }, {* S/ \9 M( y
               
0 a/ U& Y/ F3 B9 a9 }                // 记录当前趟数查找到的最大值的数组下标
( I( `  E; |! z9 c                int max;3 w+ @* J% v; W" m) U% ]
                8 G+ G" ]  J- {1 A
                // 交换变量
: D! Y. B0 a" B2 F2 E: |* Y. B3 D1 `                int temp;
+ Q. {- V4 v* b0 H4 a3 [5 H                : Z: A" s+ f9 m# ?0 k6 `
                System.out.println("排序前:" + Arrays.toString(arr));
5 p! X/ R6 `* a5 O: \
( i3 N9 ?' b, V% `! X                // 外层控制循环需要排序的趟数
3 i" d; P$ }& e* h' H$ [; Y                for(int i = 0; i < arr.length - 1; i++) {9 C& E4 o# s9 x* o
                        // 每一趟都默认数组第一个元素为最大值
, G8 i/ x/ }9 Y& \, z5 k% B                        max = 0;$ `6 x" t* z3 y! _# Q' [3 [
                       
, S3 B' g: a. X$ O3 W                        // 内循环控制遍历数组的个数(每趟减1),并得到最大数的下标! ^& T0 f9 D' `- K
                        for (int j = 0; j < arr.length - i; j++) {! T) {& ^9 T5 d0 G; g* \4 c4 |9 w
                                if (arr[j] > arr[max]) {
, l' O3 Z; I8 V$ V  f. [                                        max = j;
! `' l: |1 Q; ]. e4 q' J                                }7 A, G2 \" q1 l7 q
                        }
/ i# @8 n7 e: ~8 x                       
2 C3 z* H) e+ ~) r                        // 将交换变量设置为最大值, 将最大值暂存一下
2 r1 A, c& G) I6 w  j: S                        temp = arr[max];- ]) B1 ?. ?! L7 \: x
                        // 将当前最大值设置为当前未排序序列的最后一个元素值5 P# T; l, Q' H5 F
                        arr[max] = arr[arr.length - 1 - i];  `) R+ m$ }/ {% D* W" ^9 s
                        // 将刚才缓存的最大值,设置为当前未排序队列的最后一个元素,完成交换/ T. c4 o" A; ]. A
                        arr[arr.length - 1 - i] = temp;
8 O: t( J' o( V$ A. h5 A                }4 |) V5 Q0 ]" r; Z6 F+ O
               
9 i: ^' |. c( C8 \' f* N                System.out.println("排序后:" + Arrays.toString(arr));& }" Q' Y" `: W! Y0 w6 c7 q6 p
        }
' H( e3 D0 c8 ?0 e% W# H/ w}2 y6 l2 r4 ^9 X

# _9 {5 h8 J2 f& J关键步骤:
) j# U/ }& O  r3 g$ S! G
& e  n5 X7 T  I5 l8 ]6 i( q1. 首先定义两个变量:分别表示最大值标 和 交换变量;3 a$ P1 F! ]' a2 z6 g/ M& R% e# F

( I1 `6 n. V' x6 H6 ~2. 通过外层for循环,控制排序的趟数;9 h1 _3 S) C+ v* v! h3 E

, S! p: Y! B/ A! l) @5 Y3. 通过内循环控制每趟需要遍历数组的次数,每趟会较上一趟减1,每次会得到最大值的下标。再下一趟外循环会将这个下标重新置为0;
9 F6 s2 O3 S$ p& P* L6 ?$ R  f- M4 T% z! N* y. l
4. 每趟找到最大值后,将交换变量设置为最大值,目的是将最大值进行一个暂存;
& N$ e. q1 G  {5 g/ d/ W# I
1 ?) F  s. f( V$ G5.然后将最大值设置为当前未排序序列的最后一个元素;: M+ _$ o4 u. S  a3 w2 J4 E

# Z2 n6 w; q" q" Y: d' y6.最后将第4步缓存的最大值,设置为的当前未排序序列的最后一个元素. q- t* c- m! n" G% V0 q! L
& y1 J+ {+ V+ ], d8 l+ S) @
7.至此完成数据交换,继续进行步骤2,直到数据数据有序。% r* o. q% e, B  `# D
! L6 R# z1 l& d0 J4 k- t" {0 M
执行结果
& [8 B* j+ }6 i# B( n
% w! n9 U1 d5 a————————————————! a5 i- o$ c' q+ ?, K. X
版权声明:本文为CSDN博主「大林子先森」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。% L: y9 h/ A! G- a4 U
原文链接:https://blog.csdn.net/liulianglin/article/details/126741594+ g) c1 a9 ?% I8 Y6 R

( }  j; c& R* S0 t) M5 a7 {
! i" p+ |' w4 e- F, u- E




欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5