数学建模社区-数学中国
标题:
排序算法--选择排序(Java实现)
[打印本页]
作者:
杨利霞
时间:
2022-9-8 10:05
标题:
排序算法--选择排序(Java实现)
排序算法--选择排序(Java实现)
. B H+ z$ z, \ y4 {1 k7 E* k
! s: I. Q2 ]1 z5 o2 }6 h
选择排序概念
: [% t* B, d6 `% W) M
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 --form baike
L! F; r2 ]0 k- Y1 h
2 b; T( m! v9 f8 h) A5 {1 }) k
思想
8 t/ f) v2 {9 Z! l" J# `5 _( k3 @
* 每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置
# z2 u# \0 R1 [- E9 u
* 长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;
# } e8 s0 ~6 {
* 当进行下一次排序时,范围缩小1
3 q6 ^& B0 E9 T: w2 M+ L
- u$ C; }% [3 r: Q" L4 W& ^$ r
代码实现
1 Y: Y3 x6 _1 ?2 A: O6 Q
package com.lll.datastructure.sort;
7 B. T4 X5 B4 L
; e6 O" s, e# ~$ L
import java.util.Arrays;
8 g: r$ o. i' V' E3 n- N
0 H7 x- I& A6 S, l' \7 U8 @
/**
: f7 H. k4 b+ X( \2 a: I
*
( ^8 Z! m$ I5 b. R3 |! @, r* l
* @ClassName: SelectionSort
K& c8 {2 T5 j$ s' L) T {* _0 ^; V
* @Description: 选择排序
; u# N- \% K" F0 s
* @Author: liulianglin
/ _4 N. ^! t3 P- t9 G6 V' g2 P
* @DateTime 2022年9月7日 上午9:12:13
; j1 |4 P7 ~% O" C" g( S( O7 e
*
! \8 P( {2 s9 O9 u
* 选择排序思想:
' ?" ?/ y3 u3 J# P4 x
* 每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置
7 g1 w3 i1 T1 k& h
* 长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;
' Y7 g t) B3 ]# J0 j/ @. f' M
当进行下一次排序时,范围缩小1
* ?4 O! x6 m1 o. Z8 L( X3 m
*/
_# f$ A3 r# e# b S" \
public class SelectionSort {
; y' j7 Z; d- z5 Q1 b5 }! s
public static void main(String[] args) {
/ w0 S* r9 r5 ?% a8 T
// 待排序数据
5 B9 @& L# b1 w" A6 L
int[] arr = {1,3,2,4,7,54,11,34,9};
/ @/ x6 |% Q' w
1 n1 `% Q t1 s2 {2 d+ g; Z
// 记录当前趟数查找到的最大值的数组下标
. E0 S- s0 x3 ~/ n; M; S
int max;
$ N1 J( a6 I, s3 g( E" k( {
; A5 O r* z$ t( }, S" O8 _
// 交换变量
' m: x/ M' y r6 A& l
int temp;
$ Z8 y; l0 m% j$ C
( Y* K8 I1 p# r# C# `
System.out.println("排序前:" + Arrays.toString(arr));
- X3 Z+ p( d/ A. ^
( }1 l& f( k; i0 b# q J) b1 k
// 外层控制循环需要排序的趟数
3 ~( R- S9 p3 i
for(int i = 0; i < arr.length - 1; i++) {
& h, \- B+ `' u. O6 y# D% H+ x! P
// 每一趟都默认数组第一个元素为最大值
; E# W4 ^7 K, s' n4 f8 X% @4 A. i
max = 0;
$ }+ H! C( v' S8 \
6 W: l3 W, v8 O
// 内循环控制遍历数组的个数(每趟减1),并得到最大数的下标
) t% D& R+ Z% Q5 ?) }. A) ~- S7 B, F
for (int j = 0; j < arr.length - i; j++) {
b6 _: M+ f2 o& r/ x, t0 J: E
if (arr[j] > arr[max]) {
- h1 D% k% y/ p1 A
max = j;
6 Z2 t* k9 s$ [" m" L6 K% R0 }
}
3 d+ ?4 Y4 {8 [0 h+ t7 \/ @
}
8 g5 M+ Q3 X9 }4 l- g
% Q1 m" j+ q9 G
// 将交换变量设置为最大值, 将最大值暂存一下
8 M' H# f5 }: n" E
temp = arr[max];
/ U$ k- u5 u$ V* C
// 将当前最大值设置为当前未排序序列的最后一个元素值
( j! C0 O! q( f: f" ~+ O
arr[max] = arr[arr.length - 1 - i];
7 B" O5 \0 x- L+ D: W* S3 M
// 将刚才缓存的最大值,设置为当前未排序队列的最后一个元素,完成交换
- h9 K( Q. m3 B5 N+ D1 V8 \
arr[arr.length - 1 - i] = temp;
" B) N* [. t0 X7 N( J
}
0 \7 n+ E4 d0 l- i3 G
2 B1 }: `( b( D0 ]8 |! d( |
System.out.println("排序后:" + Arrays.toString(arr));
, x/ o2 I" U" ]# x! I% _+ z
}
/ \/ x% q3 N$ p( h9 W# Q
}
) U: g# q3 z2 o7 ^3 H6 \
E9 t, S8 S6 j) x- C& J; ]3 L
关键步骤:
- C! ]" g$ o5 n- B; \, [
7 ]7 }) P' O1 a' H: W' o; q
1. 首先定义两个变量:分别表示最大值标 和 交换变量;
. a9 W, e- l6 R1 W
8 T3 F# Q& @9 h6 h/ b
2. 通过外层for循环,控制排序的趟数;
: ?( t6 R8 ?- j2 J+ T7 ~9 m, u. o
. n; W* H9 |* v7 Y- v
3. 通过内循环控制每趟需要遍历数组的次数,每趟会较上一趟减1,每次会得到最大值的下标。再下一趟外循环会将这个下标重新置为0;
3 O6 F1 R# P# v {" e$ h
- p% B" w( A! G S1 t4 ~
4. 每趟找到最大值后,将交换变量设置为最大值,目的是将最大值进行一个暂存;
1 ]' u* C. ~* u; P1 Y1 z1 }
5 L* S# M8 B8 Q4 W% M
5.然后将最大值设置为当前未排序序列的最后一个元素;
4 m' e3 D$ H% p# q3 t) F6 E, Z
. E( K% l6 v# ~* V# y
6.最后将第4步缓存的最大值,设置为的当前未排序序列的最后一个元素
* h# Z6 O: ] j v5 I
% N* l5 z% z5 r
7.至此完成数据交换,继续进行步骤2,直到数据数据有序。
) [6 \6 i* e# a2 B9 U6 }, Y
6 R+ L3 c* N: q. b+ H. v, y3 I+ ~% g. V
执行结果
' J3 O, H+ m& M
/ Z* r( O$ {( k6 U6 v3 R" a
————————————————
7 ?8 p" f% ~* o- J# U
版权声明:本文为CSDN博主「大林子先森」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
' G, {8 Y- R- Z$ f1 w [( i6 G7 @
原文链接:https://blog.csdn.net/liulianglin/article/details/126741594
4 A" c* y- t( T6 n9 ~6 x1 N+ c
! i5 a& o' ~$ U( D" m! Y
/ j- Z: b2 q8 {% ~
欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)
Powered by Discuz! X2.5