西门子Protal_TIA SCL编程实例_排序算法
西门子SCL编程_排序算法
项目上需要,因此研究了一下排序
参考1：北岛李工 西门子SCL语言编程实例——冒泡排序
参考2：《漫画算法：小灰的算法之旅》
参考3：鸡尾酒排序优化版
参考4：西门子array数据类型_西门子SCL编程入门教程连载(16)-Variant相关指令
参考5：西门子SCL博途中如何读取泛型数组——任意长度的最大值及索引
参考6：Variant类型
参考7：SCL高级语言编写如何开启运行时间最少的几台设备
参考8：TIA protal与SCL从入门到精通（5）——函数终止跳转处理
参考9：博图SCL_递归算法的应用
参考10：李工谈工控
冒泡排序
FUNCTION "bubbleSort" : Void
TITLE = bubble sort
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : bootloader
VERSION : 0.1
//冒泡排序,使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。
VAR_INPUT
mode : Bool; // 0升序、1降序
END_VAR
VAR_IN_OUT
arraySort : Array[*] of Int;
END_VAR
VAR_TEMP
lowBound : DInt; // 数组下限
upBound : DInt; // 数组上限
i : Int; // 循环变量i
j : Int; // 循环变量j
tmpInt : Int; // 临时变量int
END_VAR
BEGIN
//冒泡排序,使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。
//作者：bootloader
//2022年3月25日 11:30 周五
//获取数组上限
#upBound := UPPER_BOUND(ARR := #arraySort, DIM := 1);
//获取数组下限
#lowBound := LOWER_BOUND(ARR := #arraySort, DIM := 1);
FOR #i := #lowBound TO #upBound DO
FOR #j := #lowBound TO #upBound - #i DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] > #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
END_IF;
ELSE
//降序
IF #arraySort[#j] < #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
END_IF;
END_IF;
;
END_FOR;
END_FOR;
END_FUNCTION
冒泡排序Upd1
FUNCTION "bubbleSort_Upd1" : Void
TITLE = bubble sort
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : bootloader
VERSION : 0.1
//冒泡排序第2版
VAR_INPUT
mode : Bool; // 0升序、1降序
END_VAR
VAR_IN_OUT
arraySort : Array[*] of Int;
END_VAR
VAR_TEMP
lowBound : DInt; // 数组下限
upBound : DInt; // 数组上限
i : Int; // 循环变量i
j : Int; // 循环变量j
tmpInt : Int; // 临时变量int
isSorted : Bool; // 有序标记
END_VAR
BEGIN
//冒泡排序,使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。
//如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，则说明数列已然有序，然后直接跳出大循环。
//作者：bootloader
//2022年3月26日 15:12 周六
//获取数组上限
#upBound := UPPER_BOUND(ARR := #arraySort, DIM := 1);
//获取数组下限
#lowBound := LOWER_BOUND(ARR := #arraySort, DIM := 1);
FOR #i := #lowBound TO #upBound DO
#isSorted := TRUE; //有序标记,每一轮的初始值都是true
FOR #j := #lowBound TO #upBound - #i DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] > #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
//因为有元素进行交换，所以不是有序的，标记为false
#isSorted := FALSE;
END_IF;
ELSE
//降序
IF #arraySort[#j] < #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
//因为有元素进行交换，所以不是有序的，标记为false
#isSorted := FALSE;
END_IF;
END_IF;
END_FOR;
IF #isSorted THEN
RETURN;
END_IF;
END_FOR;
END_FUNCTION
冒泡排序Upd2
FUNCTION "bubbleSort_Upd2" : Void
TITLE = bubble sort
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : bootloader
VERSION : 0.1
//冒泡排序第3版
VAR_INPUT
mode : Bool; // 0升序、1降序
END_VAR
VAR_IN_OUT
arraySort : Array[*] of Int;
END_VAR
VAR_TEMP
lowBound : DInt; // 数组下限
upBound : DInt; // 数组上限
i : Int; // 循环变量i
j : Int; // 循环变量j
tmpInt : Int; // 临时变量int
isSorted : Bool; // 有序标记
lastExchangeIndex : Int; // 最后一次交换的位置
sortBorder : DInt; // 无序数列的边界
END_VAR
BEGIN
//冒泡排序,使用双循环进行排序。外部循环控制所有的回合，内部循环实现每一轮的冒泡处理，先进行元素比较，再进行元素交换。
//如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，则说明数列已然有序，然后直接跳出大循环。
//使用lastExchangeIndex记录最后一次交换的位置，sortBorde记录无序数列的边界
//作者：bootloader
//2022年3月26日 18:27 周六
//获取数组上限
#upBound := UPPER_BOUND(ARR := #arraySort, DIM := 1);
//获取数组下限
#lowBound := LOWER_BOUND(ARR := #arraySort, DIM := 1);
//--记录最后一次交换的位置--
#lastExchangeIndex := 0;
//--无序数列的边界，每次比较只需要比到这里为止--
#sortBorder := #upBound; //数组curVT_tmp中最大下标30
FOR #i := #lowBound TO #upBound DO
#isSorted := TRUE; //有序标记,每一轮的初始值都是true
FOR #j := #lowBound TO #sortBorder - 1 DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] > #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
//因为有元素进行交换，所以不是有序的，标记为false
#isSorted := FALSE;
//更新为最后一次交换元素的位置
#lastExchangeIndex := #j;
END_IF;
ELSE
//降序
IF #arraySort[#j] < #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
//因为有元素进行交换，所以不是有序的，标记为false
#isSorted := FALSE;
//更新为最后一次交换元素的位置
#lastExchangeIndex := #j;
END_IF;
END_IF;
END_FOR;
#sortBorder := #lastExchangeIndex;
IF #isSorted THEN
RETURN;
END_IF;
END_FOR;
END_FUNCTION
鸡尾酒排序
FUNCTION "CocktailOrdering" : Void
TITLE = Cocktail ordering
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : bootloader
VERSION : 0.1
//鸡尾酒排序
VAR_INPUT
mode : Bool; // 0升序、1降序
END_VAR
VAR_IN_OUT
arraySort : Array[*] of Int;
END_VAR
VAR_TEMP
lowBound : DInt; // 数组下限
upBound : DInt; // 数组上限
i : Int; // 循环变量i
j : Int; // 循环变量j
tmpInt : Int; // 临时变量int
isSorted : Bool; // 有序标记
END_VAR
BEGIN
//鸡尾酒排序又称双向冒泡排序、鸡尾酒搅拌排序、搅拌排序、涟漪排序、来回排序或快乐小时排序, 是冒泡排序的一种变形。该算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。
//作者：bootloader
//2022年3月27日 02:08 周日
//获取数组上限
#upBound := UPPER_BOUND(ARR := #arraySort, DIM := 1);
//获取数组下限
#lowBound := LOWER_BOUND(ARR := #arraySort, DIM := 1);
FOR #i := #lowBound TO #upBound / 2 DO //数组长度的一半
//有序标记,每一轮的初始值都是true
#isSorted := TRUE;
//奇数轮，从左向右比较和交换
FOR #j := #i TO #upBound - #i DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] > #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
//有元素交换，所以不是有序的，标记为false
#isSorted := FALSE;
END_IF;
ELSE
//升序
IF #arraySort[#j] < #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
//有元素交换，所以不是有序的，标记为false
#isSorted := FALSE;
END_IF;
END_IF;
END_FOR;
IF #isSorted THEN
RETURN;
END_IF;
//在偶数轮之前，将#isSorted重新标记为true
#isSorted := TRUE;
//偶数轮，从右向做比较和交换
FOR #j := (#upBound - #i) TO (#i + 1) BY -1 DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] < #arraySort[#j - 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j - 1];
#arraySort[#j - 1] := #tmpInt;
//有元素交换，所以不是有序的，标记为false
#isSorted := FALSE;
END_IF;
ELSE
//降序
IF #arraySort[#j] > #arraySort[#j - 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j - 1];
#arraySort[#j - 1] := #tmpInt;
//有元素交换，所以不是有序的，标记为false
#isSorted := FALSE;
END_IF;
END_IF;
END_FOR;
IF #isSorted THEN
RETURN;
END_IF;
END_FOR;
END_FUNCTION
鸡尾酒排序Upd1
FUNCTION "CocktailOrdering_Upd1" : Void
TITLE = Cocktail ordering
{ S7_Optimized_Access := 'TRUE' }
AUTHOR : bootloader
VERSION : 0.1
//鸡尾酒排序改进版
VAR_INPUT
mode : Bool; // 0升序、1降序
END_VAR
VAR_IN_OUT
arraySort : Array[*] of Int;
END_VAR
VAR_TEMP
lowBound : DInt; // 数组下限
upBound : DInt; // 数组上限
i : Int; // 循环变量i
j : Int; // 循环变量j
tmpInt : Int; // 临时变量int
isSorted : Bool; // 有序标记
lastRightExchangeIndex : Int; // 最后一次交换的位置
lastLeftExchangeIndex : Int; // 最后一次交换的位置
rightUnsortBorder : DInt; // 无序数列的边界
leftUnsortBorder : DInt; // 无序数列的边界
END_VAR
BEGIN
//鸡尾酒排序又称双向冒泡排序、鸡尾酒搅拌排序、搅拌排序、涟漪排序、来回排序或快乐小时排序, 是冒泡排序的一种变形。该算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。
//作者：bootloader
//2022年3月27日 21:09 周六
//获取数组上限
#upBound := UPPER_BOUND(ARR := #arraySort, DIM := 1);
//获取数组下限
#lowBound := LOWER_BOUND(ARR := #arraySort, DIM := 1);
//--记录最后一次交换的位置--
#lastRightExchangeIndex := 0; //右边界最后交换位置
#lastLeftExchangeIndex := 0; //左边界最后交换位置
//--无序数列的边界，每次比较只需要比到这里为止--
#rightUnsortBorder := #upBound - 1; //右边界初始位置
#leftUnsortBorder := #lowBound; //左边界默认位置
FOR #i := #lowBound TO #upBound / 2 DO //数组长度的一半
//有序标记,每一轮的初始值都是true
#isSorted := TRUE;
//奇数轮，从左向右比较和交换
FOR #j := #i TO #rightUnsortBorder DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] > #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
#isSorted := FALSE; //有元素交换，所以不是有序的，标记为false
#lastRightExchangeIndex := #j; //更新为最后一次交换元素的位置
END_IF;
ELSE
//降序
IF #arraySort[#j] < #arraySort[#j + 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j + 1];
#arraySort[#j + 1] := #tmpInt;
#isSorted := FALSE; //有元素交换，所以不是有序的，标记为false
#lastRightExchangeIndex := #j; //更新为最后一次交换元素的位置
END_IF;
END_IF;
END_FOR;
#rightUnsortBorder := #lastRightExchangeIndex;
IF #isSorted THEN
RETURN;
END_IF;
//偶数轮,从右到左的循环，将#isSorted重新标记为true
#isSorted := TRUE;
FOR #j := (#upBound - #i) TO (#leftUnsortBorder + 1) BY -1 DO
IF NOT #mode THEN
//升序
IF #arraySort[#j] < #arraySort[#j - 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j - 1];
#arraySort[#j - 1] := #tmpInt;
//有元素交换，所以不是有序的，标记为false
#isSorted := FALSE;
//更新为最后一次交换元素的位置
#lastLeftExchangeIndex := #j;
END_IF;
ELSE
//降序
IF #arraySort[#j] > #arraySort[#j - 1] THEN
#tmpInt := #arraySort[#j];
#arraySort[#j] := #arraySort[#j - 1];
#arraySort[#j - 1] := #tmpInt;
//有元素交换，所以不是有序的，标记为false
#isSorted := FALSE;
//更新为最后一次交换元素的位置
#lastLeftExchangeIndex := #j;
END_IF;
END_IF;
END_FOR;
#leftUnsortBorder := #lastLeftExchangeIndex;
IF #isSorted THEN
RETURN;
END_IF;
END_FOR;
END_FUNCTION
快速排序_递归
//还未开始
快速排序_非递归
//还未开始
