- 在线时间
- 1630 小时
- 最后登录
- 2024-1-29
- 注册时间
- 2017-5-16
- 听众数
- 82
- 收听数
- 1
- 能力
- 120 分
- 体力
- 564449 点
- 威望
- 12 点
- 阅读权限
- 255
- 积分
- 174558
- 相册
- 1
- 日志
- 0
- 记录
- 0
- 帖子
- 5313
- 主题
- 5273
- 精华
- 3
- 分享
- 0
- 好友
- 163
TA的每日心情 | 开心 2021-8-11 17:59 |
|---|
签到天数: 17 天 [LV.4]偶尔看看III 网络挑战赛参赛者 网络挑战赛参赛者 - 自我介绍
- 本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。
 群组: 2018美赛大象算法课程 群组: 2018美赛护航培训课程 群组: 2019年 数学中国站长建 群组: 2019年数据分析师课程 群组: 2018年大象老师国赛优 |
排序算法--选择排序(Java实现)
- H* {* ^' r, X" Y R" c, H I# y2 m
选择排序概念- _9 m/ a0 `. I# E
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 --form baike8 Y- S8 i; ^* X" f% d, r
) }) ^: Z) @; c- J* v+ [ h
思想
3 [* s8 Z/ E: C* 每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置+ f) G7 X1 B6 W+ A& Z1 s5 k) s6 ~5 K7 F
* 长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;
E% i& s1 T3 ~; @4 j* 当进行下一次排序时,范围缩小1. P# j4 n) I- j0 N% d, |
8 j; t* B1 s! x代码实现0 P' H, z1 m5 Z* n# a( E& N6 l5 h
package com.lll.datastructure.sort;
: r0 y% P) Z7 n P. \
$ x) C& e% ]" |1 c- U& \import java.util.Arrays;
1 Q0 q/ ]* k- O. S& [, l
& U" S7 t( u' U' ] H; |/**1 p$ P3 i* B) s1 ~' V( T* u
* ! D+ J- P0 n5 Q/ _, U" S
* @ClassName: SelectionSort
$ ~: `2 V# J T$ [ P. o* @Description: 选择排序( @1 h2 w8 c) `. f e# j: ^
* @Author: liulianglin) U# f% q9 d7 \/ S
* @DateTime 2022年9月7日 上午9:12:139 b9 u, C2 K) W4 ]
* : I- ^1 `9 j+ X" P# f
* 选择排序思想:
# _0 b7 q, X8 x1 p. [2 z: G, V0 {* 每次从待排序的数据元素中选出最小或最大的一个元素,存放在序列的起始或末尾位置
# h: y, R# S' F, S- ~* 长度为n的数组一共需要进行n-1趟排序,每趟排序会进行一次值的交换;. H: Z. j2 T* O
当进行下一次排序时,范围缩小1
0 m/ P( x" u% N) O$ u1 v/ O# |5 t! ^; B */& U3 U) F0 i' j/ S# P! V" }9 x$ P+ Q
public class SelectionSort {
L" q9 I7 R# _! K public static void main(String[] args) {" q7 c9 `6 x+ `
// 待排序数据- q' B3 {5 S/ }$ p* L
int[] arr = {1,3,2,4,7,54,11,34,9}; , ^5 L9 j, k: u0 r: q6 f: M6 l# k
! D4 i) a6 l9 F2 S f5 g
// 记录当前趟数查找到的最大值的数组下标
5 S# R2 ]6 c* s+ d. m7 t- D int max;% I. J+ {- `' E3 f {1 d
, o {$ n' S( e
// 交换变量% J! T0 e# q$ H; B, E) A y- R& r2 X: }
int temp;: }8 I. @- \* W9 _8 i. ?0 q- k
! }: s% w& ~9 O& I: g* j0 p System.out.println("排序前:" + Arrays.toString(arr));
0 P$ W2 G0 ~6 V, W5 X4 k) Y# R3 J. }4 r6 g
// 外层控制循环需要排序的趟数! S& Z' h$ Y+ y
for(int i = 0; i < arr.length - 1; i++) {
! N& m; o- @" V7 z4 e5 r // 每一趟都默认数组第一个元素为最大值* @! Z9 r/ S& I
max = 0;
) |# J5 ^, E* L
& Q% I# ~! |) t9 Z( [ // 内循环控制遍历数组的个数(每趟减1),并得到最大数的下标, X, x# X4 _2 C8 s+ _( g6 R% p
for (int j = 0; j < arr.length - i; j++) {
4 F+ e! v- k" v" W a/ Y3 k if (arr[j] > arr[max]) {7 I, M0 D9 e8 E- K& Z |: e
max = j;/ Y* i" O( J2 x4 ?( V
}
2 ]( u U9 Q0 ^% T. o }
4 u; g* \/ Z6 U* L! r6 W3 _4 E * Y! I5 ~0 r/ t* b$ \1 l& Z
// 将交换变量设置为最大值, 将最大值暂存一下
1 i5 X4 X+ l$ y' a8 O temp = arr[max];
" [ Q; t7 e7 K4 q7 a1 f) G0 c // 将当前最大值设置为当前未排序序列的最后一个元素值, Z8 n5 n m. Y5 A
arr[max] = arr[arr.length - 1 - i];
0 t3 W; e: r& ]# @( a c // 将刚才缓存的最大值,设置为当前未排序队列的最后一个元素,完成交换, N6 F* k2 w) Y5 Q
arr[arr.length - 1 - i] = temp;$ K8 j8 k7 t0 U4 \* X8 a9 V
}
3 F: d5 r3 B! C# O; L3 B: Y * V. B# f) @- f6 V3 s. x& g% N
System.out.println("排序后:" + Arrays.toString(arr));% x+ T8 G5 N% C; b( o
}% `' H& ?% r: ~; T- E
}
9 V* E0 _9 U; W C0 v" n3 n/ k" j3 V
! `3 G& [" W# O [8 ` f% ? G3 m关键步骤:* Q, }3 W6 \% |* L
; s1 N# [) ]7 e* z+ Q3 F% ^! s
1. 首先定义两个变量:分别表示最大值标 和 交换变量;- W0 G0 e: b* W/ T5 r& C1 l
! U' x8 I4 v/ [) F2. 通过外层for循环,控制排序的趟数;1 \- ~" C- l5 M2 L8 U3 u N Q
" Z0 S3 ]# c% Z/ {8 C$ v
3. 通过内循环控制每趟需要遍历数组的次数,每趟会较上一趟减1,每次会得到最大值的下标。再下一趟外循环会将这个下标重新置为0;, [6 g# A7 q; c! A2 p
, M) K9 _/ j) m4. 每趟找到最大值后,将交换变量设置为最大值,目的是将最大值进行一个暂存;
* Q/ F3 E+ w3 ^* Q; ^+ @3 Q( Y* K+ |
5.然后将最大值设置为当前未排序序列的最后一个元素;. S; p O+ {- ^
4 z: O* P$ r6 ]" ^/ [7 p; D6.最后将第4步缓存的最大值,设置为的当前未排序序列的最后一个元素$ @6 A( w5 W; R6 X! t
! O$ [: N; v8 Q0 a5 d7.至此完成数据交换,继续进行步骤2,直到数据数据有序。
; _" c& c& n5 h& a, ?. r: J% [: O# u
执行结果
8 |0 `- |) r; ~% C# r
$ r# o: c3 A9 x) ]; U————————————————
# M) B2 Y: z& {9 D: s5 j! P版权声明:本文为CSDN博主「大林子先森」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。4 ?" V% |- C1 A5 ^
原文链接:https://blog.csdn.net/liulianglin/article/details/126741594
3 R, @# e1 e- b- U5 J$ c: |5 {5 F9 X& \$ W0 u* S* W
9 a1 p7 J7 w, R1 d, Z ]
|
zan
|