易语言冒泡排序

算法描述

1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤,除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

511遇见

计次循环+变量循环

.版本 2
.支持库 spec
 
.局部变量 A, 整数型, , "5"
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 temp
A = { 6, 8, 5, 7, 4 }
.计次循环首 (4, i)
    .变量循环首 (4, i, -1, k)
        ' 调试输出 (A [k])
        .如果真 (A [k + 1] < A [k])  ' 如果前一个数比后一个数大
            temp = A [k]  ' 把大的赋给临时变量temp
            A [k] = A [k + 1]  ' 交换两个数组成员的值,此时A[k]一定是最小的数,
            A [k + 1] = temp           
        .如果真结束
    .变量循环尾 ()
.计次循环尾 ()
调试输出 (A)

计次循环+计次循环

.版本 2
.支持库 spec
 
.局部变量 a, 整数型, , "10"
.局部变量 n, 整数型
.局部变量 i, 整数型
.局部变量 t, 整数型
 
' //冒泡排序,从小到大
a = { 89, 56, 34, 48, 57, 62, 74, 85, 93, 105 }
.变量循环首 (1, 10, 1, n)
    .变量循环首 (1, 10 - n, 1, i)
        .如果真 (a [i] < a [i + 1])  ' <从大到小,> 从小到大
            t = a [i]
            a [i] = a [i + 1]
            a [i + 1] = t
        .如果真结束
 
    .变量循环尾 ()
.变量循环尾 ()
调试输出 (a)

判断循环首 +变量循环首

.版本 2
.支持库 spec
 
.局部变量 比较次数
.局部变量 最后比较位置
.局部变量 n, 整数型
.局部变量 temp, 整数型
.局部变量 A, 整数型, , "0"
 
A = { 6, 8, 5, 7, 4 }
比较次数 = 1
最后比较位置 = 取数组成员数 (A)
.判断循环首 (比较次数 > 0)
    比较次数 = 0
    .变量循环首 (1, 最后比较位置 - 1, 1, n)
        .如果真 (A [n] > A [n + 1])
            temp = A [n]
            A [n] = A [n + 1]  ' 这3行代码是交换用的。
            A [n + 1] = temp
            最后比较位置 = n
            比较次数 = 比较次数 + 1
        .如果真结束
 
    .变量循环尾 ()
.判断循环尾 ()
调试输出 (A)

判断循环首 +计次循环

.版本 2
.支持库 spec
 
.局部变量 成员数, 整数型
.局部变量 x, 整数型
.局部变量 i, 整数型
.局部变量 temp
.局部变量 A, 整数型, , "0"
 
A = { 6, 8, 5, 7, 4 }
成员数 = 取数组成员数 (A)
x = 1
.判断循环首 (x > 0)  ' 开始进入冒泡过程
    x = 0  ' 初始化参数
    .计次循环首 (成员数, i)  ' 循环判断开始
        .如果真 (成员数 = i)  ' 设置跳出循环的条件
            跳出循环 ()
        .如果真结束
        .如果真 (A [i] > A [i + 1])  ' 核心算法
            temp = A [i]  ' 比较两个相邻数据
            A [i] = A [i + 1]  ' 如果前大后小,那么互换
            A [i + 1] = temp  ' 如果前小后大,那么不管了
            x = x + 1  ' 如果有执行互换,则参数变动
            ' 要一直执行到不用互换为止
        .如果真结束
 
    .计次循环尾 ()
.判断循环尾 ()
调试输出 (A)

冒泡排序模块封装

.版本 2
 
.子程序 冒泡算法
.参数 数据数组, 整数型, 数组
.局部变量 比较次数
.局部变量 最后比较位置
.局部变量 变量, 整数型
.局部变量 交换变量, 整数型
 
比较次数 = 1
最后比较位置 = 取数组成员数 (数据数组)
.判断循环首 (比较次数 > 0)
    比较次数 = 0
    .变量循环首 (1, 最后比较位置 - 1, 1, 变量)
        .如果真 (数据数组 [变量] > 数据数组 [变量 + 1])
            交换变量 = 数据数组 [变量]
            数据数组 [变量] = 数据数组 [变量 + 1]  ' 这3行代码是交换用的。
            数据数组 [变量 + 1] = 交换变量
            最后比较位置 = 变量
            比较次数 = 比较次数 + 1
        .如果真结束
 
    .变量循环尾 ()
.判断循环尾 ()

冒泡排序优化

.版本 2
 
.子程序 冒泡法优化
.参数 参数组, 整数型, 数组
.局部变量 未比数据数量, 整数型
.局部变量 交换变量, 整数型
.局部变量 位置变量, 整数型
.局部变量 最后位置, 整数型
 
未比数据数量 = 取数组成员数 (参数组)
.如果真 (未比数据数量 ≤ 0)
    返回 ()
.如果真结束
.判断循环首 (未比数据数量 > 0)
    最后位置 = 0
    .变量循环首 (1, 未比数据数量 - 1, 1, 位置变量)
        .如果真 (参数组 [位置变量] > 参数组 [位置变量 + 1])  ' 前一个数大于后一个数,就将两数的位置交换
            交换变量 = 参数组 [位置变量]  ' 数据组可以是变量、文件、数据库(这里用的是变量)
            参数组 [位置变量] = 参数组 [位置变量 + 1]
            参数组 [位置变量 + 1] = 交换变量  ' 以上3行代码是交换用的
            最后位置 = 位置变量
        .如果真结束
    .变量循环尾 ()
    未比数据数量 = 最后位置  ' 下一行排序从第一个数开始到上次排序的最后被改变的位数
.判断循环尾 ()

文本冒泡排序

.版本 2
 
.子程序 文本冒泡排序
.参数 数据数组, 文本型, 数组
.参数 由小到大, 逻辑型, 可空
.局部变量 未比数据数量, 整数型
.局部变量 交换变量, 文本型
.局部变量 位置变量, 整数型
.局部变量 最后位置, 整数型
.局部变量 互换标记, 逻辑型
 
未比数据数量 = 取数组成员数 (数据数组)  ' 第一行排序比较所有数
.判断循环首 (未比数据数量 > 0)
    最后位置 = 0
    .变量循环首 (1, 未比数据数量 - 1, 1, 位置变量)
        互换标记 = 假
        .如果 (由小到大)
            .如果真 (数据数组 [位置变量] > 数据数组 [位置变量 + 1])
                互换标记 = 真
            .如果真结束
        .否则
            .如果真 (数据数组 [位置变量] < 数据数组 [位置变量 + 1])
                互换标记 = 真
            .如果真结束
        .如果结束
        .如果真 (互换标记)
            交换变量 = 数据数组 [位置变量]  ' 数据组可以是变量、文件、数据库(这里用的是变量)
            数据数组 [位置变量] = 数据数组 [位置变量 + 1]
            数据数组 [位置变量 + 1] = 交换变量  ' 以上3行代码是交换用的
            最后位置 = 位置变量
        .如果真结束
    .变量循环尾 ()
    未比数据数量 = 最后位置  ' 下一行排序从第一个数开始到上次排序的最后被改变的位数
.判断循环尾 ()

双向冒泡排序

.版本 2
.子程序 双向冒泡排序
.参数 参数组, 整数型, 数组
.局部变量 交换, 整数型
.局部变量 交换变量, 整数型
.局部变量 位置变量, 整数型
.局部变量 起始变量, 整数型
.局部变量 目标变量, 整数型
.局部变量 方向变量, 整数型

目标变量 = 取数组成员数 (参数组) - 1
.如果真 (目标变量 ≤ 0)
返回 ()
.如果真结束
方向变量 = 1
起始变量 = 1
.判断循环首 (交换 = 0)
交换 = 1
.变量循环首 (起始变量, 目标变量, 方向变量, 位置变量)
.如果 (参数组 [位置变量] > 参数组 [位置变量 + 1])
交换变量 = 参数组 [位置变量]
参数组 [位置变量] = 参数组 [位置变量 + 1]
参数组 [位置变量 + 1] = 交换变量
交换变量 = 位置变量
交换 = 0
.否则
.如果结束
.变量循环尾 ()
方向变量 = 方向变量 × -1
交换变量 = 交换变量 + 方向变量
目标变量 = 起始变量
起始变量 = 交换变量
.判断循环尾 ()

汇编法冒泡排序

.版本 2

.子程序 BubbleSort, 整数型,
.参数 array, 整数型, , 数组指针
.参数 len, 整数型, , 数组长度

置入代码 ({ 131, 236, 12, 86, 131, 125, 12, 0, 117, 8, 139, 69, 8, 233, 130, 0, 0, 0, 199, 69, 252, 0, 0, 0, 0, 235, 9, 139, 69, 252, 131, 192, 1, 137, 69, 252, 139, 77, 252, 59, 77, 12, 125, 101, 199, 69, 248, 0, 0, 0, 0, 235, 9, 139, 85, 248, 131, 194, 1, 137, 85, 248, 139, 69, 12, 131, 232, 1, 43, 69, 252, 57, 69, 248, 125, 67, 139, 77, 248, 139, 85, 8, 139, 69, 248, 139, 117, 8, 139, 76, 138, 4, 59, 12, 134, 125, 44, 139, 85, 248, 139, 69, 8, 139, 76, 144, 4, 137, 77, 244, 139, 85, 248, 139, 69, 8, 139, 77, 248, 139, 117, 8, 139, 12, 142, 137, 76, 144, 4, 139, 85, 248, 139, 69, 8, 139, 77, 244, 137, 12, 144, 235, 166, 235, 138, 139, 69, 8, 94, 139, 229, 93, 194, 8, 0 })
返回 (0)

.版本 2
.支持库 spec
 
.子程序 汇编冒泡排序
.参数 iarray, 整数型, 数组
.参数 retarray, 整数型, 参考 数组
.局部变量 len, 整数型
.局部变量 plr, 整数型
.局部变量 arrBuf, 字节集
 
len = 取数组成员数 (iarray)
plr = BubbleSort (取变量数据地址 (iarray), len)
arrBuf = 指针到字节集 (plr, len × 4)
重定义数组 (retarray,, len)
RtlMoveMemory_arrn (retarray, arrBuf, len × 4)

发布日期:

所属分类: 易语言 标签: