数组排序有一个地方，理解不透，望详细告知

xiaolong111

图中划线地方 ，取数组成员数  减去  i   是什么意思？（具体起到什么作用？）  我试了不减i 或 +i  都会出错

zainex

有这个疑问，说明你其实并不明白冒泡排序是怎么回事，或者说处在一种似懂非懂的状态，好像懂了，又好像没有。
首先我们来看看什么是排序:
把
{40 30 20 25 21}
变成
1、{20 21 25 30 40}
或者
2、{40 30 25 21 20}
我们称之为排序，也就是按顺序排列。
现在我们不考虑怎么用程序实现，而是分析之前的思考过程，看看它是怎么帮我们完成手工排序的。
面对
{40 30 20 25 21}
我会先找到其中的最大数，放到最后，变成：
{30 20 25 21 | 40}
然后以此类推
{20 25 21 | 30 40}
{20 21 | 25 30 40}
{20 | 21 25 30 40}
{| 20 21 25 30 40}
这样排序就算完成了。
这时再回到你的问题，“- i” 的目的已经显而易见。
就像我们在上面完成手工排序的过程一样，它的目的是为了缩小判断的范围，即 | 右边的是已经排序好了的，没必要再去判断。
体现在冒泡排序中的好处是减少了循环次数，比如有1百个数，不进行范围缩小，需要循环1万次，而缩小后，只需要5千次，这提高了运行速度，是一种很常见的冒泡排序优化措施。

haoren1212

谁教你这样写的

补充内容 (2024-9-10 04:50):
数组_排序(, , )。比如数组成员有三个你引用第四个能不报错嘛，直接用精易的数组排列就行了，没必要这么麻烦

乐鱼驴

计次循环首（） i  和 a  
都是1开始计算。
循环四次 是1.2.3.4
数组成员数的标记是 -1.1.2.3
也就算说 ，数组4个成员数里面没有第四个成员，最大只有   数组[3]。 这句话是核心）

蟹黄憨包

计次循环的数值循环是从1开始的，数组的索引是从0开始的，所以要减去1，不然到最后一个就会超索引，超索引就会报这个错误

走一回

下面的是从一个源码里剥离下来的，应该能行的。

  

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

数组 ＝ { 40, 30, 20, 25, 21 }
计次循环首 (5 － 1, i)
变量循环首 (5, i ＋ 1, -1, n)
如果真 (数组 [i] ＜ 数组 [n])
交换变量 (数组 [i], 数组 [n])

变量循环尾 ()
计次循环尾 ()
调试输出 (数组)

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

.版本 2<br /> .支持库 spec<br /> <br /> .局部变量 数组, 整数型, , "5"<br /> .局部变量 i<br /> .局部变量 n<br /> .局部变量 temp, 整数型<br /> <br /> 数组 ＝ { 40, 30, 20, 25, 21 }<br /> .计次循环首 (5 － 1, i)<br />     .变量循环首 (5, i ＋ 1, -1, n)<br />         .如果真 (数组 <i> ＜ 数组 [n])<br />             交换变量 (数组 <i>, 数组 [n])<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br /> .计次循环尾 ()<br /> 调试输出 (数组)

Suky

  

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

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

计次循环尾 ()
计次循环尾 ()
' 首先，看内层循环，因为引用数组成员最大引用了a+1，这时候就要保证a的最大值必须是小于数组成员数最少1
' 这时候我们的代码应该为：
. ' 计次循环首 (取数组成员数 (数组), n)
. ' 计次循环首 (取数组成员数 (数组) － 1, a)
. ' 如果真 (数组 [a] ＞ 数组 [a ＋ 1])
' 交换变量 (数组 [a], 数组 [a ＋ 1])

. ' 计次循环尾 ()
. ' 计次循环尾 ()
' 然后，按着上述代码流程逐步跟进，会发现外层循环每次循环一遍，最小的值都会被往后挪到数组下标最大的位置
' 而第一次循环之后，最小的值已经被挪到最右边了，
' 第二次循环时第二小的值在内层循环第（取数组成员数 (数组) － 1）次循环时会被挪到数组右数第二的位置，
' 此时最后一次循环跟右边比它小的值对比完全就是多余的操作了
' 所以外层循环的第二次循环，内层循环的总次数要再减去1，能减少冗余的循环次数
' 然后，外层循环第三次循环，你会发现，内层循环冗余的循环次数又多了1
' 这时总结一下规律，发现外层循环每次循环，内层循环总循环次数都递减一次，就可以去除这些冗余的循环操作
' 此时，每次外层循环时，内层循环的总次数依次是[取数组成员数 (数组)-1]、[取数组成员数 (数组)-2]……[取数组成员数 (数组)-取数组成员数 (数组)]
' 而外层循环的循环变量n的值，随着循环从1开始每次递增1，一直到取数组成员数 (数组)
' 所以就可以用n完美替代
' 最终的代码就变成了最上边的样子

.版本 2<br /> <br /> .局部变量 数组, 整数型, , "0"<br /> .局部变量 n, 整数型<br /> .局部变量 a, 整数型<br /> <br /> .计次循环首 (取数组成员数 (数组), n)<br />     .计次循环首 (取数组成员数 (数组) － n, a)<br />         .如果真 (数组 [a] ＞ 数组 [a ＋ 1])<br />             交换变量 (数组 [a], 数组 [a ＋ 1])<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> ' 首先，看内层循环，因为引用数组成员最大引用了a+1，这时候就要保证a的最大值必须是小于数组成员数最少1<br /> ' 这时候我们的代码应该为：<br /> .' 计次循环首 (取数组成员数 (数组), n)<br />     .' 计次循环首 (取数组成员数 (数组) － 1, a)<br />         .' 如果真 (数组 [a] ＞ 数组 [a ＋ 1])<br />             ' 交换变量 (数组 [a], 数组 [a ＋ 1])<br />         .如果真结束<br /> <br />     .' 计次循环尾 ()<br /> .' 计次循环尾 ()<br /> ' 然后，按着上述代码流程逐步跟进，会发现外层循环每次循环一遍，最小的值都会被往后挪到数组下标最大的位置<br /> ' 而第一次循环之后，最小的值已经被挪到最右边了，<br /> ' 第二次循环时第二小的值在内层循环第（取数组成员数 (数组) － 1）次循环时会被挪到数组右数第二的位置，<br /> ' 此时最后一次循环跟右边比它小的值对比完全就是多余的操作了<br /> ' 所以外层循环的第二次循环，内层循环的总次数要再减去1，能减少冗余的循环次数<br /> ' 然后，外层循环第三次循环，你会发现，内层循环冗余的循环次数又多了1<br /> ' 这时总结一下规律，发现外层循环每次循环，内层循环总循环次数都递减一次，就可以去除这些冗余的循环操作<br /> ' 此时，每次外层循环时，内层循环的总次数依次是[取数组成员数 (数组)-1]、[取数组成员数 (数组)-2]……[取数组成员数 (数组)-取数组成员数 (数组)]<br /> ' 而外层循环的循环变量n的值，随着循环从1开始每次递增1，一直到取数组成员数 (数组)<br /> ' 所以就可以用n完美替代<br /> ' 最终的代码就变成了最上边的样子

炫雨

最好别这样写，乱七八糟的，数组从1开始的

帅气与大侠

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

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

子程序名	返回值类型	公开	备 注
_按钮1_被单击

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

数组 ＝ { 40, 30, 20, 25, 21 }
冒泡排序_基础 (数组)
调试输出 (数组)

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

变量名	类 型	静态	数组	备 注
成员数	整数型
i	整数型
是否有交换过变量	逻辑型

成员数 ＝ 取数组成员数 (数组)
循环判断首 ()
是否有交换过变量 ＝ 假
变量循环首 (1, 成员数 － 1, 1, i)
' 为啥 成员数 - 1
' 当前值 = 数组[i]
' 下个值 = 数组[i+1]
' 可以看出是【当前值】和【下个值】比较
' 也就是【下个值】是预读的，如果成员数不减1
' 预读  【下个值】就会超过成员数，就会报错
如果真 (数组 [i] ＞ 数组 [i ＋ 1])
交换变量 (数组 [i], 数组 [i ＋ 1])
是否有交换过变量 ＝ 真

变量循环尾 ()
循环判断尾 (是否有交换过变量 ＝ 真)
' 冒泡排序过程
' 数组 = { 40, 30, 20, 25, 21 }
' 第一遍排序
' 40 > 30，结果 = { 30, 40, 20, 25, 21 }
' 40 > 20，结果 = { 30, 20, 40, 25, 21 }
' 40 > 25，结果 = { 30, 20, 25, 40, 21 }
' 40 > 21，结果 = { 30, 20, 25, 21, 40 }
' 是否有交换过变量 = 真
' 第二遍排序
' 30 > 20，结果 = { 20, 30, 25, 21, 40 }
' 30 > 25，结果 = { 20, 25, 30, 21, 40 }
' 30 > 21，结果 = { 20, 25, 21, 30, 40 }
' 30!> 40，结果 = { 20, 25, 21, 30, 40 }
' 是否有交换过变量 = 真
' 第三遍排序
' 20!> 25，结果 = { 20, 25, 21, 30, 40 }
' 25 > 21，结果 = { 20, 21, 25, 30, 40 }
' 25!> 30，结果 = { 20, 21, 25, 30, 40 }
' 30!> 40，结果 = { 20, 21, 25, 30, 40 }
' 是否有交换过变量 = 真
' 第四遍排序
' 20!> 21，结果 = { 20, 21, 25, 30, 40 }
' 21!> 25，结果 = { 20, 21, 25, 30, 40 }
' 25!> 30，结果 = { 20, 21, 25, 30, 40 }
' 30!> 40，结果 = { 20, 21, 25, 30, 40 }
' 是否有交换过变量 = 假
' 到此可以看出，最后一次排序时
' 【当前值】没有一次比【下一值】大
' 也就是没有交换过变量，表示排序完成了

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

变量名	类 型	静态	数组	备 注
成员数	整数型
i	整数型
最后位置	整数型

成员数 ＝ 取数组成员数 (数组)
判断循环首 (成员数 ＞ 0)
最后位置 ＝ 0
变量循环首 (1, 成员数 － 1, 1, i)
如果真 (数组 [i] ＞ 数组 [i ＋ 1])
交换变量 (数组 [i], 数组 [i ＋ 1])
最后位置 ＝ i

变量循环尾 ()
成员数 ＝ 最后位置
判断循环尾 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> <br /> <br /> .子程序 _按钮1_被单击<br /> .局部变量 数组, 整数型, , "0"<br /> <br /> 数组 ＝ { 40, 30, 20, 25, 21 }<br /> 冒泡排序_基础 (数组)<br /> 调试输出 (数组)<br /> <br /> .子程序 冒泡排序_基础<br /> .参数 数组, 整数型, 参考 数组<br /> .局部变量 成员数, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 是否有交换过变量, 逻辑型<br /> <br /> 成员数 ＝ 取数组成员数 (数组)<br /> <br /> .循环判断首 ()<br />     是否有交换过变量 ＝ 假<br />     .变量循环首 (1, 成员数 － 1, 1, i)<br />         ' 为啥 成员数 - 1<br />         ' 当前值 = 数组<i><br />         ' 下个值 = 数组[i+1]<br />         ' 可以看出是【当前值】和【下个值】比较<br />         ' 也就是【下个值】是预读的，如果成员数不减1<br />         ' 预读  【下个值】就会超过成员数，就会报错<br />         .如果真 (数组 <i> ＞ 数组 [i ＋ 1])<br />             交换变量 (数组 <i>, 数组 [i ＋ 1])<br />             是否有交换过变量 ＝ 真<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br /> .循环判断尾 (是否有交换过变量 ＝ 真)<br /> ' 冒泡排序过程<br /> ' 数组 = { 40, 30, 20, 25, 21 }<br /> <br /> ' 第一遍排序<br /> ' 40 > 30，结果 = { 30, 40, 20, 25, 21 }<br /> ' 40 > 20，结果 = { 30, 20, 40, 25, 21 }<br /> ' 40 > 25，结果 = { 30, 20, 25, 40, 21 }<br /> ' 40 > 21，结果 = { 30, 20, 25, 21, 40 }<br /> ' 是否有交换过变量 = 真<br /> <br /> <br /> ' 第二遍排序<br /> ' 30 > 20，结果 = { 20, 30, 25, 21, 40 }<br /> ' 30 > 25，结果 = { 20, 25, 30, 21, 40 }<br /> ' 30 > 21，结果 = { 20, 25, 21, 30, 40 }<br /> ' 30!> 40，结果 = { 20, 25, 21, 30, 40 }<br /> ' 是否有交换过变量 = 真<br /> <br /> <br /> ' 第三遍排序<br /> ' 20!> 25，结果 = { 20, 25, 21, 30, 40 }<br /> ' 25 > 21，结果 = { 20, 21, 25, 30, 40 }<br /> ' 25!> 30，结果 = { 20, 21, 25, 30, 40 }<br /> ' 30!> 40，结果 = { 20, 21, 25, 30, 40 }<br /> ' 是否有交换过变量 = 真<br /> <br /> <br /> ' 第四遍排序<br /> ' 20!> 21，结果 = { 20, 21, 25, 30, 40 }<br /> ' 21!> 25，结果 = { 20, 21, 25, 30, 40 }<br /> ' 25!> 30，结果 = { 20, 21, 25, 30, 40 }<br /> ' 30!> 40，结果 = { 20, 21, 25, 30, 40 }<br /> ' 是否有交换过变量 = 假<br /> <br /> ' 到此可以看出，最后一次排序时<br /> ' 【当前值】没有一次比【下一值】大<br /> ' 也就是没有交换过变量，表示排序完成了<br /> <br /> <br /> <br /> .子程序 冒泡排序_优化<br /> .参数 数组, 整数型, 参考 数组<br /> .局部变量 成员数, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 最后位置, 整数型<br /> <br /> 成员数 ＝ 取数组成员数 (数组)<br /> .判断循环首 (成员数 ＞ 0)<br />     最后位置 ＝ 0<br />     .变量循环首 (1, 成员数 － 1, 1, i)<br />         .如果真 (数组 <i> ＞ 数组 [i ＋ 1])<br />             交换变量 (数组 <i>, 数组 [i ＋ 1])<br />             最后位置 ＝ i<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     成员数 ＝ 最后位置<br /> .判断循环尾 ()

sunfly

直接百du冒泡排序就明白了，只是减少对比次数加快效率。
如果对 已经对比好的顺序数字再次对比也可以，只要不是百万次的重复影响不大