- 在线时间
- 1630 小时
- 最后登录
- 2024-1-29
- 注册时间
- 2017-5-16
- 听众数
- 82
- 收听数
- 1
- 能力
- 120 分
- 体力
- 565618 点
- 威望
- 12 点
- 阅读权限
- 255
- 积分
- 174908
- 相册
- 1
- 日志
- 0
- 记录
- 0
- 帖子
- 5313
- 主题
- 5273
- 精华
- 3
- 分享
- 0
- 好友
- 163
TA的每日心情 | 开心 2021-8-11 17:59 |
|---|
签到天数: 17 天 [LV.4]偶尔看看III 网络挑战赛参赛者 网络挑战赛参赛者 - 自我介绍
- 本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。
 群组: 2018美赛大象算法课程 群组: 2018美赛护航培训课程 群组: 2019年 数学中国站长建 群组: 2019年数据分析师课程 群组: 2018年大象老师国赛优 |
排序算法--选择排序(Java实现)- X' T+ T" D ?3 n
, e; J" u- `" [ e6 ?选择排序概念
# m n/ s' l; X7 D: \ 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 --form baike
+ b" m, F* Z' w0 C# ]1 l: @9 U' t. ?/ ]; Q0 ?& T1 _
思想: ?" [: S. Q& p# e( @$ s# ^* i
* 每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置
6 W4 H" x7 c4 h- w$ P* 长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;, T' {4 O+ G9 n
* 当进行下一次排序时,范围缩小1" G" U. Y* M' @( ?& @' h
6 k/ T5 T4 X1 K, H7 M; K; y
代码实现6 }6 `# E* I& o
package com.lll.datastructure.sort;% n" t) J6 R1 y- A, T, q
: q4 a& X9 f5 J1 P. \* r \. i
import java.util.Arrays;
9 f. J- Y* c: `9 _! K" Z0 j6 q, l4 x# `0 R% n d& v* S
/**
) d1 \0 |* q0 Q7 ?: w * * I q3 A! n( K5 K4 t0 a
* @ClassName: SelectionSort
- n# n- T+ X, M* @Description: 选择排序# C5 a5 A0 L; z* [. U5 T
* @Author: liulianglin7 z' H; y) @* c
* @DateTime 2022年9月7日 上午9:12:13+ d; b9 B) |4 |7 E) y p
*
V4 b% i8 W3 R6 v* 选择排序思想:
7 r( b( ^/ { r1 D6 ^1 f. X j* 每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置) M9 U s) R9 ^6 d9 X1 D+ D$ ?' W
* 长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;
3 G0 ~8 E" G T3 G( C) O2 d3 y 当进行下一次排序时,范围缩小10 i2 }) V' W" l( t
*/! n/ N8 J: p* ?! }4 N& |) s8 X
public class SelectionSort {! z% I& V4 Q; f; p
public static void main(String[] args) {
+ }7 v# F9 l6 A, w" r // 待排序数据
5 i8 w1 ?" X- I0 j+ l int[] arr = {1,3,2,4,7,54,11,34,9}; * R! H1 t. e9 r# v! ]! R
6 Q# M g. ^9 q7 C! \0 H2 G5 B
// 记录当前趟数查找到的最大值的数组下标
' H8 `; D# S, C7 c: n int max;
# J# X, E2 |* q' p n: p ! m* E6 _- g8 A4 H" j4 u6 N
// 交换变量% I: w/ G9 A! I
int temp;
) K; ^+ W+ Z& Y2 }7 ^. w3 Z8 _1 l / q" _# t* M6 _: t" F) l: G7 j
System.out.println("排序前:" + Arrays.toString(arr));
! G3 o2 ]% ?% f0 O% `, D+ Z4 u* X0 o8 u4 e5 d& a
// 外层控制循环需要排序的趟数
9 V9 k; }" E5 o: B4 X for(int i = 0; i < arr.length - 1; i++) {' z1 i; {9 u( B, ^
// 每一趟都默认数组第一个元素为最大值
8 c, Z1 W( D; p. M7 O max = 0;: [' Y8 V( Z5 }" E, o& V9 N* D
& f4 l' G7 v9 b! S4 R // 内循环控制遍历数组的个数(每趟减1),并得到最大数的下标4 h& |7 V4 T* L/ K
for (int j = 0; j < arr.length - i; j++) {9 L# S' y: {5 g, i! X8 W2 m
if (arr[j] > arr[max]) {
& f0 B( m: v1 s" Y max = j;- ]1 m1 x- P9 y* O, [( l/ A
}
: n' n1 \- k* z4 t }$ K( ?* ?+ L1 U- q6 L
# B# B: A+ z2 M // 将交换变量设置为最大值, 将最大值暂存一下
3 v; C; g# q" y0 R temp = arr[max];
2 |% ]; ~# ]3 S- F' _, B // 将当前最大值设置为当前未排序序列的最后一个元素值: c* b2 y' v- U! }1 B' v
arr[max] = arr[arr.length - 1 - i];
; V) V( U. u* |" B5 w // 将刚才缓存的最大值,设置为当前未排序队列的最后一个元素,完成交换2 S( v1 m$ d! }4 Q2 F+ p
arr[arr.length - 1 - i] = temp;
I, I" o7 p. l7 x( G4 m }
3 g0 h1 B% S: B& Z
1 x, c1 S( e9 \2 x7 S' P, A& D System.out.println("排序后:" + Arrays.toString(arr));
1 D: R* _$ ^) D2 J* ? }
5 m! q4 V$ I2 G$ r5 G; ]1 Z( Z}
v h8 g' O: V2 X$ s: Z. t
' i6 h) ^' q) E; P; E( z关键步骤:
# T( Z7 s( S) c0 t1 s+ G& |
( l# }; l4 R5 E) G6 z1. 首先定义两个变量:分别表示最大值标 和 交换变量;
2 v7 m/ U: _% ?+ u. S% A. c+ a* d+ ~+ M/ k0 U& }2 s+ O) L4 G
2. 通过外层for循环,控制排序的趟数;
3 P6 E+ c2 \1 [2 [/ q& f5 q8 i# E* ~7 o1 G# `( f8 s
3. 通过内循环控制每趟需要遍历数组的次数,每趟会较上一趟减1,每次会得到最大值的下标。再下一趟外循环会将这个下标重新置为0;! ?% p% ~" h- ^0 o+ l% z3 V c
, U z! p8 Z; a! M) ^* J* p( D
4. 每趟找到最大值后,将交换变量设置为最大值,目的是将最大值进行一个暂存;& H- w% T/ Q- V+ }
]4 H' X, V" U+ d2 [: a5.然后将最大值设置为当前未排序序列的最后一个元素;
1 ?1 V6 @# t- r5 _
( G u, R6 P# Y5 ^' a& s+ O6.最后将第4步缓存的最大值,设置为的当前未排序序列的最后一个元素
A* J3 v; A' z
0 M8 {1 ]+ b+ ]# G# y' E7.至此完成数据交换,继续进行步骤2,直到数据数据有序。2 X( e$ |& f, \
/ T* _ z6 P6 W/ y
执行结果7 [9 }; M- L" a
4 i( B: ?; H9 q* V; N————————————————
* i! U) d( v* N) x. {, n2 |1 f版权声明:本文为CSDN博主「大林子先森」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
9 ^- A9 @- J r" m. m$ D原文链接:https://blog.csdn.net/liulianglin/article/details/1267415948 [; P- G5 k3 i H; {/ ]
2 j' N1 j% u0 h# j2 C
$ C4 K0 M4 [+ B- o/ Y+ X |
zan
|