我和豆包写的排序排序 TimSort

APPLEUFO

https://www.bilibili.com/video/BV1944y1E7as/?vd_source=95702c8745c5d28582eab4405ef02eef
介绍了一个 算法   ， 插入和归并混合排序的
f阀值 32. 小于32的成员用插入，然后两两合并起来归并排序
然后我写了主框架。

让豆包把插入排序，和归并排序的部分，补上
插入排序写的十分完美。然后让它改成更快的二分插入排序   也改出来了  

  

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

变量名	类 型	静态	数组	备 注
n1	整数型
局变_临时	整数型
m1	整数型
局变_插入点	整数型

如果 (参数_左 ≥ 参数_右)
返回 ()



调试输出 (子程序_输出指定数组成员 (参数_数组, 参数_左, 参数_右))
变量循环首 (参数_左 ＋ 1, 参数_右, 1, n1)
局变_临时 ＝ 参数_数组 [n1]  ' 设置插入值
局变_插入点 ＝ -1  ' 初始化插入点
' 调试输出 (局变_临时, n1)
' 查找插入位置
变量循环首 (n1 － 1, 参数_左, -1, m1)
如果 (参数_数组 [m1] ＞ 局变_临时)
参数_数组 [m1 ＋ 1] ＝ 参数_数组 [m1]  ' 元素后移
局变_插入点 ＝ m1 ＋ 1  ' 找到插入点
跳出循环 ()

变量循环尾 ()
' 处理最小元素的情况
如果 (局变_插入点 ＝ -1)
局变_插入点 ＝ 参数_左



参数_数组 [局变_插入点] ＝ 局变_临时  ' 插入元素
' 调试输出 (子程序_输出指定数组成员 (参数_数组, 参数_左, 参数_右))
变量循环尾 ()
调试输出 (子程序_输出指定数组成员 (参数_数组, 参数_左, 参数_右))

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 子程序_插入排序3<br /> .参数 参数_数组, 整数型, 数组<br /> .参数 参数_左, 整数型<br /> .参数 参数_右, 整数型<br /> .局部变量 n1, 整数型<br /> .局部变量 局变_临时, 整数型<br /> .局部变量 m1, 整数型<br /> .局部变量 局变_插入点, 整数型<br /> <br /> .如果 (参数_左 ≥ 参数_右)<br />     返回 ()<br /> .否则<br /> <br /> .如果结束<br /> <br /> 调试输出 (子程序_输出指定数组成员 (参数_数组, 参数_左, 参数_右))<br /> <br /> .变量循环首 (参数_左 ＋ 1, 参数_右, 1, n1)<br />     局变_临时 ＝ 参数_数组 [n1]  ' 设置插入值<br />     局变_插入点 ＝ -1  ' 初始化插入点<br /> <br />     ' 调试输出 (局变_临时, n1)<br /> <br />     ' 查找插入位置<br />     .变量循环首 (n1 － 1, 参数_左, -1, m1)<br />         .如果 (参数_数组 [m1] ＞ 局变_临时)<br />             参数_数组 [m1 ＋ 1] ＝ 参数_数组 [m1]  ' 元素后移<br />         .否则<br />             局变_插入点 ＝ m1 ＋ 1  ' 找到插入点<br />             跳出循环 ()<br />         .如果结束<br /> <br />     .变量循环尾 ()<br /> <br />     ' 处理最小元素的情况<br />     .如果 (局变_插入点 ＝ -1)<br />         局变_插入点 ＝ 参数_左<br />     .否则<br /> <br />     .如果结束<br /> <br />     参数_数组 [局变_插入点] ＝ 局变_临时  ' 插入元素<br /> <br />     ' 调试输出 (子程序_输出指定数组成员 (参数_数组, 参数_左, 参数_右))<br /> .变量循环尾 ()<br /> <br /> 调试输出 (子程序_输出指定数组成员 (参数_数组, 参数_左, 参数_右))

  

子程序名	返回值类型	公开	备 注
子程序_二分插入排序3
参数名	类 型	参考	可空	数组	备 注
参数_数组	整数型
参数_左	整数型
参数_右	整数型

变量名	类 型	静态	数组	备 注
n1	整数型
局变_临时	整数型
局变_左	整数型
局变_右	整数型
局变_中间	整数型
m1	整数型

' 边界检查：无需排序的情况
如果 (参数_左 ≥ 参数_右)
返回 ()



' 从第二个元素开始插入排序
变量循环首 (参数_左 ＋ 1, 参数_右, 1, n1)
局变_临时 ＝ 参数_数组 [n1]  ' 保存当前插入值
局变_左 ＝ 参数_左  ' 二分查找左边界
局变_右 ＝ n1 － 1  ' 二分查找右边界
' 二分查找插入位置
判断循环首 (局变_左 ≤ 局变_右)
局变_中间 ＝ 局变_左 ��� (局变_右 － 局变_左) ÷ 2  ' 避免溢出
如果 (参数_数组 [局变_中间] ＞ 局变_临时)
局变_右 ＝ 局变_中间 － 1  ' 目标在左半部分
局变_左 ＝ 局变_中间 ＋ 1  ' 目标在右半部分

判断循环尾 ()
' 元素后移（从插入位置到当前位置）
变量循环首 (n1 － 1, 局变_左, -1, m1)
参数_数组 [m1 ＋ 1] ＝ 参数_数组 [m1]
变量循环尾 ()
' 插入元素
参数_数组 [局变_左] ＝ 局变_临时
变量循环尾 ()

.版本 2<br /> <br /> .子程序 子程序_二分插入排序3<br /> .参数 参数_数组, 整数型, 数组<br /> .参数 参数_左, 整数型<br /> .参数 参数_右, 整数型<br /> .局部变量 n1, 整数型<br /> .局部变量 局变_临时, 整数型<br /> .局部变量 局变_左, 整数型<br /> .局部变量 局变_右, 整数型<br /> .局部变量 局变_中间, 整数型<br /> .局部变量 m1, 整数型<br /> <br /> ' 边界检查：无需排序的情况<br /> .如果 (参数_左 ≥ 参数_右)<br />     返回 ()<br /> .否则<br /> <br /> .如果结束<br /> <br /> ' 从第二个元素开始插入排序<br /> .变量循环首 (参数_左 ＋ 1, 参数_右, 1, n1)<br />     局变_临时 ＝ 参数_数组 [n1]  ' 保存当前插入值<br />     局变_左 ＝ 参数_左  ' 二分查找左边界<br />     局变_右 ＝ n1 － 1  ' 二分查找右边界<br /> <br />     ' 二分查找插入位置<br />     .判断循环首 (局变_左 ≤ 局变_右)<br />         局变_中间 ＝ 局变_左 ＋ (局变_右 － 局变_左) ÷ 2  ' 避免溢出<br />         .如果 (参数_数组 [局变_中间] ＞ 局变_临时)<br />             局变_右 ＝ 局变_中间 － 1  ' 目标在左半部分<br />         .否则<br />             局变_左 ＝ 局变_中间 ＋ 1  ' 目标在右半部分<br />         .如果结束<br /> <br />     .判断循环尾 ()<br /> <br />     ' 元素后移（从插入位置到当前位置）<br />     .变量循环首 (n1 － 1, 局变_左, -1, m1)<br />         参数_数组 [m1 ＋ 1] ＝ 参数_数组 [m1]<br />     .变量循环尾 ()<br /> <br />     ' 插入元素<br />     参数_数组 [局变_左] ＝ 局变_临时<br /> .变量循环尾 ()

豆包可以啊,插入排序的改版也能轻松实现  我想半天
直接输入残缺代码  他就补上了




它搞不清循环判断 和判断循环。有时候忘记循环判断尾（）里加 真



然后让他补上  归并排序的代码。也整挺好，除了一点拷贝到IDE的错乱外，也能跑了
提示修改一些bug后，连主框架都改成看不懂的样子‘但是结果是没问题的


本来非常费脑子的事情   AI给解决了
用是没问题的，就是要理解代码和修改BUG就很难了

然后看看完整代码   

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
程变_临时	整数型	0	用于归并排序的临时数组

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

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

' 调试模块_创建整数型数组_无重复 (aaa, 10000000)
调试模块_创建整数型数组_有重复 (aaa, 10000000, 1, 100000)
bbb ＝ aaa
' aaa ＝ { 94, 29, 43, 16, 65, 80, 31, 33, 88, 92, 41, 61, 34, 52, 44, 19, 56, 4, 18, 90, 57, 38, 2, 28, 48, 32, 89, 81, 36, 69, 14, 85, 62, 24, 54, 84, 96, 9, 3, 63, 76, 82, 58, 73, 20, 93, 1, 55, 98, 67, 40, 22, 97, 51, 27, 17, 79, 77, 71, 10, 45, 74, 8, 47, 25, 12, 6, 35, 75, 83, 23, 87, 100, 60, 13, 30, 37, 78, 68, 95, 91, 53, 99, 21, 5, 26, 49, 72, 70, 50, 59, 86, 42, 46, 64, 39, 66, 11, 15, 7 }
' 调试输出 (aaa)
计时器启动 ()
子程序_新排序 (aaa)
计时器结束 ()
计时器启动 ()
排序模块_归并排序 (bbb)
计时器结束 ()
' 调试输出 (aaa)
调试输出 (调试模块_检查数组是否排序过 (aaa, 真))
调试输出 (调试模块_检查数组是否排序过 (bbb, 真))
结束 ()
' 全局临时数组，避免重复创建
' 全局临时数组，避免重复创建
' 全局临时数组，用于归并排序
' 全局临时数组，用于归并排序
' 全局临时数组（归并排序专用，解决跨子程序访问问题）

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

变量名	类 型	静态	数组	备 注
局变_阀值	整数型			默认32
局变_数组个数	整数型
局变_间隔	整数型
局变_左	整数型
局变_右	整数型
局变_游标x首	整数型
局变_游标x尾	整数型
局变_游标y首	整数型
局变_游标y尾	整数型

' 初始化参数
局变_阀值 ＝ 32
局变_数组个数 ＝ 取数组成员数 (参数_数组)
' 空数组或单元素数组无需排序
如果 (局变_数组个数 ≤ 1)
返回 ()



' 小数组直接用二分插入排序
如果 (局变_数组个数 ＜ 局变_阀值)
子程序_二分插入排序3 (参数_数组, 1, 局变_数组个数)
返回 ()



' 初始化临时数组（大小与原数组一致）
重定义数组 (程变_临时, 假, 局变_数组个数)
' 第一阶段：按阀值分割数组并排序每个子段
局变_左 ＝ 1
局变_间隔 ＝ 局变_阀值
循环判断首 ()
' 计算右边界并修正（防止越界）
局变_右 ＝ 局变_左 ＋ 局变_间隔 － 1
如果 (局变_右 ＞ 局变_数组个数)
局变_右 ＝ 局变_数组个数



' 确保左边界≤右边界（避免无效排序）
如果 (局变_左 ＞ 局变_右)
跳出循环 ()



' 排序当前子段
子程序_二分插入排序3 (参数_数组, 局变_左, 局变_右)
' 移动到下一个子段
局变_左 ＝ 局变_右 ＋ 1
' 所有子段处理完毕，退出循环
如果 (局变_左 ＞ 局变_数组个数)
跳出循环 ()



循环判断尾 (真)
' 第二阶段：归并排序（逐步合并子数组）
局变_间隔 ＝ 局变_阀值
循环判断首 ()
局变_游标x首 ＝ 1  ' 每次从数组头部开始归并
' 归并当前间隔下的所有相邻子数组
循环判断首 ()
' 计算左子数组边界并修正
局变_游标x尾 ＝ 局变_游标x首 ＋ 局变_间隔 － 1
如果 (局变_游标x尾 ＞ 局变_数组个数)
局变_游标x尾 ＝ 局变_数组个数



' 计算右子数组起始位置
局变_游标y首 ＝ 局变_游标x尾 ＋ 1
' 右子数组不存在（已到数组末尾），退出当前间隔的归并
如果 (局变_游标y首 ＞ 局变_数组个数)
跳出循环 ()



' 计算右子数组边界并修正
局变_游标y尾 ＝ 局变_游标y首 ＋ 局变_间隔 － 1
如果 (局变_游标y尾 ＞ 局变_数组个数)
局变_游标y尾 ＝ 局变_数组个数



' 归并两个相邻子数组
子程序_归并排序_正常 (参数_数组, 局变_游标x首, 局变_游标x尾, 局变_游标y首, 局变_游标y尾)
' 移动到下一组子数组
局变_游标x首 ＝ 局变_游标y尾 ＋ 1
' 所有组处理完毕，退出当前间隔的归并
如果 (局变_游标x首 ＞ 局变_数组个数)
跳出循环 ()



循环判断尾 (真)
' 间隔翻倍（归并更大的子数组）
局变_间隔 ＝ 局变_间隔 × 2
' 间隔超过数组长度，排序完成
如果 (局变_间隔 ＞ 局变_数组个数)
跳出循环 ()



循环判断尾 (真)

子程序名	返回值类型	公开	备 注
子程序_二分插入排序3
参数名	类 型	参考	可空	数组	备 注
参数_数组	整数型
参数_左	整数型
参数_右	整数型

变量名	类 型	静态	数组	备 注
n1	整数型
局变_临时	整数型
局变_左	整数型
局变_右	整数型
局变_中间	整数型
m1	整数型

' 边界检查：无需排序的情况
如果 (参数_左 ≥ 参数_右)
返回 ()



' 从第二个元素开始插入排序
变量循环首 (参数_左 ＋ 1, 参数_右, 1, n1)
局变_临时 ＝ 参数_数组 [n1]  ' 保存当前插入值
局变_左 ＝ 参数_左  ' 二分查找左边界
局变_右 ＝ n1 － 1  ' 二分查找右边界
' 二分查找插入位置
判断循环首 (局变_左 ≤ 局变_右)
局变_中间 ＝ 局变_左 ��� (局变_右 － 局变_左) ÷ 2  ' 避免溢出
如果 (参数_数组 [局变_中间] ＞ 局变_临时)
局变_右 ＝ 局变_中间 － 1  ' 目标在左半部分
局变_左 ＝ 局变_中间 ＋ 1  ' 目标在右半部分

判断循环尾 ()
' 元素后移（从插入位置到当前位置）
变量循环首 (n1 － 1, 局变_左, -1, m1)
参数_数组 [m1 ＋ 1] ＝ 参数_数组 [m1]
变量循环尾 ()
' 插入元素
参数_数组 [局变_左] ＝ 局变_临时
变量循环尾 ()

子程序名	返回值类型	公开	备 注
子程序_归并排序_正常
参数名	类 型	参考	可空	数组	备 注
参数_数组	整数型
参数_游标x首	整数型
参数_游标x尾	整数型
参数_游标y首	整数型
参数_游标y尾	整数型

变量名	类 型	静态	数组	备 注
局变_i	整数型			' 左子数组游标
局变_j	整数型			' 右子数组游标
局变_k	整数型			' 结果数组游标

' 边界检查：无效参数直接返回
如果 (参数_游标x首 ＞ 参数_游标x尾 或 参数_游标y首 ＞ 参数_游标y尾)
返回 ()



' 将待归并的元素复制到临时数组
变量循环首 (参数_游标x首, 参数_游标y尾, 1, 局变_i)
程变_临时 [局变_i] ＝ 参数_数组 [局变_i]
变量循环尾 ()
' 初始化游标
局变_i ＝ 参数_游标x首
局变_j ＝ 参数_游标y首
局变_k ＝ 参数_游标x首
' 归并两个有序子数组
循环判断首 ()
' 左子数组已处理完，复制右子数组剩余元素
如果 (局变_i ＞ 参数_游标x尾)
变量循环首 (局变_j, 参数_游标y尾, 1, 局变_j)
参数_数组 [局变_k] ＝ 程变_临时 [局变_j]
局变_k ＝ 局变_k ＋ 1
变量循环尾 ()
跳出循环 ()



' 右子数组已处理完，复制左子数组剩余元素
如果 (局变_j ＞ 参数_游标y尾)
变量循环首 (局变_i, 参数_游标x尾, 1, 局变_i)
参数_数组 [局变_k] ＝ 程变_临时 [局变_i]
局变_k ＝ 局变_k ＋ 1
变量循环尾 ()
跳出循环 ()



' 比较并取较小元素
如果 (程变_临时 [局变_i] ≤ 程变_临时 [局变_j])
参数_数组 [局变_k] ＝ 程变_临时 [局变_i]
局变_i ＝ 局变_i ＋ 1
参数_数组 [局变_k] ＝ 程变_临时 [局变_j]
局变_j ＝ 局变_j ＋ 1
局变_k ＝ 局变_k ＋ 1
循环判断尾 (真)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 程变_临时, 整数型, , "0", 用于归并排序的临时数组<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 aaa, 整数型, , "0"<br /> .局部变量 bbb, 整数型, , "0"<br /> <br /> ' 调试模块_创建整数型数组_无重复 (aaa, 10000000)<br /> 调试模块_创建整数型数组_有重复 (aaa, 10000000, 1, 100000)<br /> bbb ＝ aaa<br /> <br /> ' aaa ＝ { 94, 29, 43, 16, 65, 80, 31, 33, 88, 92, 41, 61, 34, 52, 44, 19, 56, 4, 18, 90, 57, 38, 2, 28, 48, 32, 89, 81, 36, 69, 14, 85, 62, 24, 54, 84, 96, 9, 3, 63, 76, 82, 58, 73, 20, 93, 1, 55, 98, 67, 40, 22, 97, 51, 27, 17, 79, 77, 71, 10, 45, 74, 8, 47, 25, 12, 6, 35, 75, 83, 23, 87, 100, 60, 13, 30, 37, 78, 68, 95, 91, 53, 99, 21, 5, 26, 49, 72, 70, 50, 59, 86, 42, 46, 64, 39, 66, 11, 15, 7 }<br /> ' 调试输出 (aaa)<br /> <br /> 计时器启动 ()<br /> 子程序_新排序 (aaa)<br /> 计时器结束 ()<br /> <br /> 计时器启动 ()<br /> 排序模块_归并排序 (bbb)<br /> 计时器结束 ()<br /> ' 调试输出 (aaa)<br /> 调试输出 (调试模块_检查数组是否排序过 (aaa, 真))<br /> 调试输出 (调试模块_检查数组是否排序过 (bbb, 真))<br /> 结束 ()<br /> ' 全局临时数组，避免重复创建<br /> ' 全局临时数组，避免重复创建<br /> ' 全局临时数组，用于归并排序<br /> ' 全局临时数组，用于归并排序<br /> ' 全局临时数组（归并排序专用，解决跨子程序访问问题）<br /> <br /> <br /> .子程序 子程序_新排序<br /> .参数 参数_数组, 整数型, 数组<br /> .局部变量 局变_阀值, 整数型, , , 默认32<br /> .局部变量 局变_数组个数, 整数型<br /> .局部变量 局变_间隔, 整数型<br /> .局部变量 局变_左, 整数型<br /> .局部变量 局变_右, 整数型<br /> .局部变量 局变_游标x首, 整数型<br /> .局部变量 局变_游标x尾, 整数型<br /> .局部变量 局变_游标y首, 整数型<br /> .局部变量 局变_游标y尾, 整数型<br /> <br /> ' 初始化参数<br /> 局变_阀值 ＝ 32<br /> 局变_数组个数 ＝ 取数组成员数 (参数_数组)<br /> <br /> ' 空数组或单元素数组无需排序<br /> .如果 (局变_数组个数 ≤ 1)<br />     返回 ()<br /> .否则<br /> <br /> .如果结束<br /> <br /> ' 小数组直接用二分插入排序<br /> .如果 (局变_数组个数 ＜ 局变_阀值)<br />     子程序_二分插入排序3 (参数_数组, 1, 局变_数组个数)<br />     返回 ()<br /> .否则<br /> <br /> .如果结束<br /> <br /> ' 初始化临时数组（大小与原数组一致）<br /> 重定义数组 (程变_临时, 假, 局变_数组个数)<br /> <br /> ' 第一阶段：按阀值分割数组并排序每个子段<br /> 局变_左 ＝ 1<br /> 局变_间隔 ＝ 局变_阀值<br /> .循环判断首 ()<br />     ' 计算右边界并修正（防止越界）<br />     局变_右 ＝ 局变_左 ＋ 局变_间隔 － 1<br />     .如果 (局变_右 ＞ 局变_数组个数)<br />         局变_右 ＝ 局变_数组个数<br />     .否则<br /> <br />     .如果结束<br /> <br />     ' 确保左边界≤右边界（避免无效排序）<br />     .如果 (局变_左 ＞ 局变_右)<br />         跳出循环 ()<br />     .否则<br /> <br />     .如果结束<br /> <br />     ' 排序当前子段<br />     子程序_二分插入排序3 (参数_数组, 局变_左, 局变_右)<br /> <br />     ' 移动到下一个子段<br />     局变_左 ＝ 局变_右 ＋ 1<br /> <br />     ' 所有子段处理完毕，退出循环<br />     .如果 (局变_左 ＞ 局变_数组个数)<br />         跳出循环 ()<br />     .否则<br /> <br />     .如果结束<br /> <br /> .循环判断尾 (真)<br /> <br /> ' 第二阶段：归并排序（逐步合并子数组）<br /> 局变_间隔 ＝ 局变_阀值<br /> .循环判断首 ()<br />     局变_游标x首 ＝ 1  ' 每次从数组头部开始归并<br /> <br />     ' 归并当前间隔下的所有相邻子数组<br />     .循环判断首 ()<br />         ' 计算左子数组边界并修正<br />         局变_游标x尾 ＝ 局变_游标x首 ＋ 局变_间隔 － 1<br />         .如果 (局变_游标x尾 ＞ 局变_数组个数)<br />             局变_游标x尾 ＝ 局变_数组个数<br />         .否则<br /> <br />         .如果结束<br /> <br />         ' 计算右子数组起始位置<br />         局变_游标y首 ＝ 局变_游标x尾 ＋ 1<br /> <br />         ' 右子数组不存在（已到数组末尾），退出当前间隔的归并<br />         .如果 (局变_游标y首 ＞ 局变_数组个数)<br />             跳出循环 ()<br />         .否则<br /> <br />         .如果结束<br /> <br />         ' 计算右子数组边界并修正<br />         局变_游标y尾 ＝ 局变_游标y首 ＋ 局变_间隔 － 1<br />         .如果 (局变_游标y尾 ＞ 局变_数组个数)<br />             局变_游标y尾 ＝ 局变_数组个数<br />         .否则<br /> <br />         .如果结束<br /> <br />         ' 归并两个相邻子数组<br />         子程序_归并排序_正常 (参数_数组, 局变_游标x首, 局变_游标x尾, 局变_游标y首, 局变_游标y尾)<br /> <br />         ' 移动到下一组子数组<br />         局变_游标x首 ＝ 局变_游标y尾 ＋ 1<br /> <br />         ' 所有组处理完毕，退出当前间隔的归并<br />         .如果 (局变_游标x首 ＞ 局变_数组个数)<br />             跳出循环 ()<br />         .否则<br /> <br />         .如果结束<br /> <br />     .循环判断尾 (真)<br /> <br />     ' 间隔翻倍（归并更大的子数组）<br />     局变_间隔 ＝ 局变_间隔 × 2<br /> <br />     ' 间隔超过数组长度，排序完成<br />     .如果 (局变_间隔 ＞ 局变_数组个数)<br />         跳出循环 ()<br />     .否则<br /> <br />     .如果结束<br /> <br /> .循环判断尾 (真)<br /> <br /> .子程序 子程序_二分插入排序3<br /> .参数 参数_数组, 整数型, 数组<br /> .参数 参数_左, 整数型<br /> .参数 参数_右, 整数型<br /> .局部变量 n1, 整数型<br /> .局部变量 局变_临时, 整数型<br /> .局部变量 局变_左, 整数型<br /> .局部变量 局变_右, 整数型<br /> .局部变量 局变_中间, 整数型<br /> .局部变量 m1, 整数型<br /> <br /> ' 边界检查：无需排序的情况<br /> .如果 (参数_左 ≥ 参数_右)<br />     返回 ()<br /> .否则<br /> <br /> .如果结束<br /> <br /> ' 从第二个元素开始插入排序<br /> .变量循环首 (参数_左 ＋ 1, 参数_右, 1, n1)<br />     局变_临时 ＝ 参数_数组 [n1]  ' 保存当前插入值<br />     局变_左 ＝ 参数_左  ' 二分查找左边界<br />     局变_右 ＝ n1 － 1  ' 二分查找右边界<br /> <br />     ' 二分查找插入位置<br />     .判断循环首 (局变_左 ≤ 局变_右)<br />         局变_中间 ＝ 局变_左 ＋ (局变_右 － 局变_左) ÷ 2  ' 避免溢出<br />         .如果 (参数_数组 [局变_中间] ＞ 局变_临时)<br />             局变_右 ＝ 局变_中间 － 1  ' 目标在左半部分<br />         .否则<br />             局变_左 ＝ 局变_中间 ＋ 1  ' 目标在右半部分<br />         .如果结束<br /> <br />     .判断循环尾 ()<br /> <br />     ' 元素后移（从插入位置到当前位置）<br />     .变量循环首 (n1 － 1, 局变_左, -1, m1)<br />         参数_数组 [m1 ＋ 1] ＝ 参数_数组 [m1]<br />     .变量循环尾 ()<br /> <br />     ' 插入元素<br />     参数_数组 [局变_左] ＝ 局变_临时<br /> .变量循环尾 ()<br /> <br /> .子程序 子程序_归并排序_正常<br /> .参数 参数_数组, 整数型, 数组<br /> .参数 参数_游标x首, 整数型<br /> .参数 参数_游标x尾, 整数型<br /> .参数 参数_游标y首, 整数型<br /> .参数 参数_游标y尾, 整数型<br /> .局部变量 局变_i, 整数型, , , ' 左子数组游标<br /> .局部变量 局变_j, 整数型, , ,  ' 右子数组游标<br /> .局部变量 局变_k, 整数型, , , ' 结果数组游标<br /> <br /> ' 边界检查：无效参数直接返回<br /> .如果 (参数_游标x首 ＞ 参数_游标x尾 或 参数_游标y首 ＞ 参数_游标y尾)<br />     返回 ()<br /> .否则<br /> <br /> .如果结束<br /> <br /> ' 将待归并的元素复制到临时数组<br /> .变量循环首 (参数_游标x首, 参数_游标y尾, 1, 局变_i)<br />     程变_临时 [局变_i] ＝ 参数_数组 [局变_i]<br /> .变量循环尾 ()<br /> <br /> ' 初始化游标<br /> 局变_i ＝ 参数_游标x首<br /> 局变_j ＝ 参数_游标y首<br /> 局变_k ＝ 参数_游标x首<br /> <br /> ' 归并两个有序子数组<br /> .循环判断首 ()<br />     ' 左子数组已处理完，复制右子数组剩余元素<br />     .如果 (局变_i ＞ 参数_游标x尾)<br />         .变量循环首 (局变_j, 参数_游标y尾, 1, 局变_j)<br />             参数_数组 [局变_k] ＝ 程变_临时 [局变_j]<br />             局变_k ＝ 局变_k ＋ 1<br />         .变量循环尾 ()<br />         跳出循环 ()<br />     .否则<br /> <br />     .如果结束<br /> <br />     ' 右子数组已处理完，复制左子数组剩余元素<br />     .如果 (局变_j ＞ 参数_游标y尾)<br />         .变量循环首 (局变_i, 参数_游标x尾, 1, 局变_i)<br />             参数_数组 [局变_k] ＝ 程变_临时 [局变_i]<br />             局变_k ＝ 局变_k ＋ 1<br />         .变量循环尾 ()<br />         跳出循环 ()<br />     .否则<br /> <br />     .如果结束<br /> <br />     ' 比较并取较小元素<br />     .如果 (程变_临时 [局变_i] ≤ 程变_临时 [局变_j])<br />         参数_数组 [局变_k] ＝ 程变_临时 [局变_i]<br />         局变_i ＝ 局变_i ＋ 1<br />     .否则<br />         参数_数组 [局变_k] ＝ 程变_临时 [局变_j]<br />         局变_j ＝ 局变_j ＋ 1<br />     .如果结束<br />     局变_k ＝ 局变_k ＋ 1<br /> .循环判断尾 (真)

aosheng

6666666666666666

一指温柔

支持开源~！感谢分享

艾玛克138

坚持学习,支持论坛

wuqingg

笨来无一悟

功德无量

pipicool

学习一下

冯古屋

这非常有趣

胖子葛格

感谢大神分享~！

张升

感谢分享，很给力！~

bianyuan456

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