数组排序_选秀算法_冒泡算法变种

Suky

  

子程序名	返回值类型	公开	备 注
_启动子程序	整数型		本子程序在程序启动后最先执行

变量名	类 型	静态	数组	备 注
array	整数型		0

array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组
数组排序_选秀算法 (array)  ' 对数组进行排序
调试输出 (array)  ' 排序后的数组
调试输出 (取重复文本 (30, “==”))
array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组
数组排序_冒泡算法 (array)  ' 对数组进行排序
调试输出 (array)  ' 排序后的数组
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
数组排序_选秀算法			2024年3月9日 15:16:38 Suky
参数名	类 型	参考	可空	数组	备 注
array	整数型

变量名	类 型	静态	数组	备 注
i	整数型
n	整数型

计次循环首 (取数组成员数 (array) － 1, i)
变量循环首 (i, 取数组成员数 (array) － 1, 1, n)
如果真 (array [i] ＞ array [n ＋ 1])
交换变量 (array [i], array [n ＋ 1])

变量循环尾 ()
调试输出 (i, array)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
数组排序_冒泡算法			根据实际情况对非数组进行排序
参数名	类 型	参考	可空	数组	备 注
array	整数型				根据实际情况改变数据类型

变量名	类 型	静态	数组	备 注
i	整数型
j	整数型

计次循环首 (取数组成员数 (array) － 1, i)
计次循环首 (取数组成员数 (array) － i, j)
如果真 (array [j] ＞ array [j ＋ 1])  ' 改变符号可使排列顺序相反
交换变量 (array [j], array [j ＋ 1])

计次循环尾 ()
调试输出 (i, array)
计次循环尾 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 array, 整数型, , "0"<br /> <br /> array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组<br /> 数组排序_选秀算法 (array)  ' 对数组进行排序<br /> 调试输出 (array)  ' 排序后的数组<br /> 调试输出 (取重复文本 (30, “==”))<br /> array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组<br /> 数组排序_冒泡算法 (array)  ' 对数组进行排序<br /> 调试输出 (array)  ' 排序后的数组<br /> <br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 数组排序_选秀算法, , , 2024年3月9日 15:16:38 Suky<br /> .参数 array, 整数型, 参考 数组<br /> .局部变量 i, 整数型<br /> .局部变量 n, 整数型<br /> <br /> .计次循环首 (取数组成员数 (array) － 1, i)<br />     .变量循环首 (i, 取数组成员数 (array) － 1, 1, n)<br />         .如果真 (array <i> ＞ array [n ＋ 1])<br />             交换变量 (array <i>, array [n ＋ 1])<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     调试输出 (i, array)<br /> .计次循环尾 ()<br /> <br /> .子程序 数组排序_冒泡算法, , , 根据实际情况对非数组进行排序<br /> .参数 array, 整数型, 参考 数组, 根据实际情况改变数据类型<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> <br /> .计次循环首 (取数组成员数 (array) － 1, i)<br />     .计次循环首 (取数组成员数 (array) － i, j)<br />         .如果真 (array [j] ＞ array [j ＋ 1])  ' 改变符号可使排列顺序相反<br />             交换变量 (array [j], array [j ＋ 1])<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     调试输出 (i, array)<br /> .计次循环尾 ()

与常用冒泡算法的不同点在于：
冒泡算法是每次循环，将两个方向的极值逐步向数组两端移动
选秀算法是每次循环，将要取的极值向数组前方指定位置置换，由于取值行为类似舞台选秀，故名选秀算法


与常用冒泡算法相比，速度没差别
唯一优势在于特定场景扩展应用，例如：
要从数组 { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 } 中取出最小的3个数来用
那么可使用类似的变造排序代码：

  

变量名	类 型	静态	数组	备 注
array	整数型		0
接收数组	整数型		0

' array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组
' 数组排序_选秀算法 (array)  ' 对数组进行排序
' 调试输出 (array)  ' 排序后的数组
' 调试输出 (取重复文本 (30, “==”))
array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组
数组排序_选取指定数量值 (array, 3, 接收数组)  ' 对数组进行排序
调试输出 (接收数组)  ' 排序后的数组
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
数组排序_选取指定数量值			2024年3月9日 15:16:38 Suky
参数名	类 型	参考	可空	数组	备 注
参数数组	整数型
数量	整数型
接收数组	整数型

变量名	类 型	静态	数组	备 注
array	整数型		0
i	整数型
n	整数型

array ＝ 参数数组
计次循环首 (数量, i)
变量循环首 (i, 取数组成员数 (array) － 1, 1, n)
如果真 (array [i] ＞ array [n ＋ 1])
交换变量 (array [i], array [n ＋ 1])

变量循环尾 ()
加入成员 (接收数组, array [i])
计次循环尾 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .局部变量 array, 整数型, , "0"<br /> .局部变量 接收数组, 整数型, , "0"<br /> <br /> ' array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组<br /> ' 数组排序_选秀算法 (array)  ' 对数组进行排序<br /> ' 调试输出 (array)  ' 排序后的数组<br /> ' 调试输出 (取重复文本 (30, “==”))<br /> array ＝ { 153, 245, 421, 352, 154, 12, 352, 62, 54, 652, 36, 15, 423, 57 }  ' 原数组<br /> 数组排序_选取指定数量值 (array, 3, 接收数组)  ' 对数组进行排序<br /> 调试输出 (接收数组)  ' 排序后的数组<br /> <br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 数组排序_选取指定数量值, , , 2024年3月9日 15:16:38 Suky<br /> .参数 参数数组, 整数型, 参考 数组<br /> .参数 数量, 整数型<br /> .参数 接收数组, 整数型, 数组<br /> .局部变量 array, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 n, 整数型<br /> <br /> array ＝ 参数数组<br /> .计次循环首 (数量, i)<br />     .变量循环首 (i, 取数组成员数 (array) － 1, 1, n)<br />         .如果真 (array <i> ＞ array [n ＋ 1])<br />             交换变量 (array <i>, array [n ＋ 1])<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     加入成员 (接收数组, array <i>)<br /> .计次循环尾 ()

来自群组: 热心网友

福仔

Suky 发表于 2024-3-10 22:24
应该就冒泡最容易理解吧，所以大部分人普遍用的是冒泡排序
另外两种很少看到有人用 ...

都差不多, 冒泡是两两比较, 大的就往后放, 循环是从0 到 总数-1, 0 到 总数-2, 0 到 总数-3....
选择排序就是找到最小值, 然后和当前位置交换, 循环是从0 到 总数-1, 1 到 总数-1, 2 到 总数-1.....
插入排序相对来说可能用得还比较多一些, 在数据量小的时候可以用这种排序
插入排序就是每次都拿当前位置的值和左边的值比较, 如果比左边小, 那就交换到左边
循环是从当前位置到 0, 比如 1 到 0, 2 到 0, 3 到 0, .... 一直到 总数-1 到 0
但是这个循环有退出的条件, 就是当前的数不比左边小就退出本次循环
相对选择排序和冒泡排序来说是会快一些

  

子程序名	返回值类型	公开	备 注
_临时子程序

变量名	类 型	静态	数组	备 注
数组	整数型		0
总数	整数型
i	整数型

总数 ＝ 取随机数 (5, 10)
重定义数组 (数组, 假, 总数)
计次循环首 (总数, i)
数组 [i] ＝ 取随机数 (1, 100)
计次循环尾 ()
调试输出 (数组)
插入排序 (数组)
调试输出 (数组)

子程序名	返回值类型	公开	备 注
插入排序
参数名	类 型	参考	可空	数组	备 注
数组	整数型

变量名	类 型	静态	数组	备 注
总数	整数型
i	整数型
j	整数型
左边的值	整数型
当前的值	整数型

总数 ＝ 取数组成员数 (数组)
' 易语言的数组从1开始, 所以下面的值都+1
变量循环首 (2, 总数, 1, i)  ' 当前位置从2开始
变量循环首 (i － 1, 1, -1, j)  ' 当前位置到1, 第一次就是 2 到 1, 因为i从2开始, 第二次就是 3 到 1, 以此类推
左边的值 ＝ 数组 [j]
当前的值 ＝ 数组 [j ＋ 1]
判断 (当前的值 ＜ 左边的值)  ' 当前值小于左边的值, 那就交换
交换变量 (数组 [j], 数组 [j ＋ 1])
跳出循环 ()  ' 不小于左边的值就退出本次循环

变量循环尾 ()
变量循环尾 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _临时子程序<br /> .局部变量 数组, 整数型, , "0"<br /> .局部变量 总数, 整数型<br /> .局部变量 i, 整数型<br /> <br /> 总数 ＝ 取随机数 (5, 10)<br /> 重定义数组 (数组, 假, 总数)<br /> .计次循环首 (总数, i)<br />     数组 <i> ＝ 取随机数 (1, 100)<br /> .计次循环尾 ()<br /> 调试输出 (数组)<br /> 插入排序 (数组)<br /> 调试输出 (数组)<br /> <br /> .子程序 插入排序<br /> .参数 数组, 整数型, 数组<br /> .局部变量 总数, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> .局部变量 左边的值, 整数型<br /> .局部变量 当前的值, 整数型<br /> <br /> 总数 ＝ 取数组成员数 (数组)<br /> ' 易语言的数组从1开始, 所以下面的值都+1<br /> .变量循环首 (2, 总数, 1, i)  ' 当前位置从2开始<br /> <br />     .变量循环首 (i － 1, 1, -1, j)  ' 当前位置到1, 第一次就是 2 到 1, 因为i从2开始, 第二次就是 3 到 1, 以此类推<br />         左边的值 ＝ 数组 [j]<br />         当前的值 ＝ 数组 [j ＋ 1]<br />         .判断开始 (当前的值 ＜ 左边的值)  ' 当前值小于左边的值, 那就交换<br />             交换变量 (数组 [j], 数组 [j ＋ 1])<br />         .默认<br />             跳出循环 ()  ' 不小于左边的值就退出本次循环<br />         .判断结束<br /> <br />     .变量循环尾 ()<br /> .变量循环尾 ()

可以用扑克牌来理解, 比如你手上有一些牌, 已经排好了, 这时你又摸一张牌上来
那就是从右边往左边看, 看看是大于哪一张牌那, 就插入到那张牌后面

胖子葛格

感谢大神分享~！

year1970

感谢分享

xiang316367725

虽然现在还不懂，但还是支持开源的大佬们

pipicool

学习一下

TPAN898

感谢分享，很给力！~

蓝桉已遇释槐鸟

6666666666666666666

一指温柔

        感谢分享，很给力！~

光影魔术

感谢分享

bianyuan456

已经顶贴，感谢您对论坛的支持！