Common Algorithms
Declare an Array
// 声明一个长度为10的整型数组 NumList
DECLARE NumList: ARRAY[1:10] OF INTEGER
Initialization
// 将数组 NumList 中的元素随机初始化为 10 到 99 之间的整数
PROCEDURE Initialization
DECLARE Index: INTEGER
FOR Index <- 1 TO 10
NumList[Index] <- ROUND(RANDOM() * 89 + 10, 0)
NEXT Index
ENDPROCEDURE
Totalling
// 计算数组 NumList 中所有元素的和
FUNCTION Totalling() RETURNS INTEGER
DECLARE Index: INTEGER
DECLARE Sum: INTEGER
Sum <- 0
// 遍历数组中的每个元素
FOR Index <- 1 TO 10
// 将当前的元素累加到 Sum 中
Sum <- Sum + NumList[Index]
NEXT Index
RETURN Sum
ENDFUNCTION
Counting
// 统计数组 NumList 中质数的个数
FUNCTION CountingPrime() RETURNS INTEGER
DECLARE Index: INTEGER
DECLARE Counter: INTEGER
DECLARE IsPrime: BOOLEAN
DECLARE Factor: INTEGER
Counter <- 0
// 遍历数组中的每个元素
FOR Index <- 1 TO 10
// 判断当前元素是否为质数
IsPrime <- TRUE
FOR Factor <- 2 TO DIV(NumList[Index], 2)
IF MOD(NumList[Index], Factor) = 0
THEN
IsPrime <- FALSE
ENDIF
NEXT Factor
// 如果是质数，则计数器加 1
IF IsPrime = TRUE
THEN
Counter <- Counter + 1
ENDIF
NEXT Index
RETURN Counter
ENDFUNCTION
Average
// 计算数组 NumList 中偶数的平均值
FUNCTION AverageOfEvens() RETURNS REAL
DECLARE Index: INTEGER
DECLARE Count: INTEGER
DECLARE Sum: INTEGER
DECLARE Average: REAL
Count <- 0
Sum <- 0
// 遍历数组中的每个元素
FOR Index <- 1 TO 10
// 判断当前元素是否为偶数
IF MOD(NumList[Index], 2) = 0
THEN
// 将当前元素累加到 Sum 中
Sum <- Sum + NumList[Index]
// 计数器加 1
Count <- Count + 1
ENDIF
NEXT Index
// 计算平均值
Average <- Sum / Count
RETURN Average
ENDFUNCTION
Finding Maximum
// 寻找数组 NumList 中的最大值的位置
FUNCTION FindMax() RETURNS INTEGER
DECLARE Index: INTEGER
DECLARE Max: INTEGER
DECLARE MaxPos: INTEGER
// 初始化最大值和最大值的位置
Max <- 0
MaxPos <- -1
// 遍历数组中的每个元素
FOR Index <- 1 TO 10
// 判断当前元素是否大于最大值
IF Max < NumList[Index]
THEN
// 更新最大值和最大值的位置
Max <- NumList[Index]
MaxPos <- Index
ENDIF
NEXT Index
// 返回最大值的位置
RETURN MaxPos
ENDFUNCTION
Finding Minimum
// 寻找数组 NumList 中的最小值的位置
FUNCTION FindMin() RETURNS INTEGER
DECLARE Index: INTEGER
DECLARE Min: INTEGER
DECLARE MinPos: INTEGER
// 初始化最小值和最小值的位置
Min <- 100
MinPos <- -1
// 遍历数组中的每个元素
FOR Index <- 1 TO 10
// 判断当前元素是否小于最小值
IF Min > NumList[Index]
THEN
// 更新最小值和最小值的位置
Min <- NumList[Index]
MinPos <- Index
ENDIF
NEXT Index
// 返回最小值的位置
RETURN MinPos
ENDFUNCTION
Linear Search
// 线性查找数组 NumList 中是否存在 Target，返回其位置
// 如果不存在则返回 -1
FUNCTION LinearSearch(Target: INTEGER) RETURNS INTEGER
DECLARE Index: INTEGER
// 遍历数组中的每个元素
FOR Index <- 1 TO 10
// 判断当前元素的值是否为目标值
IF NumList[Index] = Target
THEN
// 如果是目标值，返回其位置
RETURN Index
ENDIF
NEXT Index
// 不存在目标值，返回 -1
RETURN -1
ENDFUNCTION
Bubble Sort
PROCEDURE BubbleSort
DECLARE Target: INTEGER
DECLARE Current: INTEGER
DECLARE Temp: INTEGER
// 剩余数组中的最大值移动到剩余数组的最后位置
FOR Target <- 10 TO 2 STEP -1
// 遍历剩余数组中的每个元素
FOR Current <- 1 TO (Target - 1)
// 比较相邻的两个元素
IF NumList[Current] > NumList[Current + 1]
THEN
// 如果是降序，交换两个元素
Temp <- NumList[Current]
NumList[Current] <- NumList[Current + 1]
NumList[Current + 1] <- Temp
ENDIF
NEXT Current
NEXT Target
ENDPROCEDURE
Selection Sort
PROCEDURE SelectionSort
DECLARE Target: INTEGER
DECLARE Min: INTEGER
DECLARE MinPos: INTEGER
DECLARE Temp: INTEGER
// 剩余数组中的最小值移动到剩余数组的第一个位置
FOR Target <- 1 TO 10
Min <- NumList[Target]
MinPos <- Target
// 遍历剩余数组中的每个元素，找到剩余数组中的最小值
FOR Current <- (Target + 1) TO 10
IF Min > NumList[Current]
THEN
Min <- NumList[Current]
MinPos <- Current
ENDIF
NEXT Current
// 将最小值与剩余数组的第一个位置的元素交换
Temp <- NumList[Target]
NumList[Target] <- NumList[MinPos]
NumList[MinPos] <- Temp
NEXT Target
ENDPROCEDURE
Insertion Sort
PROCEDURE InsertionSort
DECLARE Target: INTEGER
DECLARE Current: INTEGER
DECLARE Temp: INTEGER
// 从第二个元素开始，将剩余数组中的每个元素插入到已排序的数组中
FOR Target <- 2 TO 10
Current <- Target
// 从当前位置向前遍历，找到插入的位置
// 1. 如果当前位置的前一个元素比当前元素大，则交换位置，插到这个元素
的前面
//
直到找到插入的位置，停止遍历
// 2. 如果当前位置已经是数组的第一个位置，则停止遍历
WHILE (Current > 1) AND (NumList[Current - 1] >
NumList[Current]) DO
Temp <- NumList[Current]
NumList[Current] <- NumList[Current - 1]
NumList[Current - 1] <- Temp
// 从插入的位置开始继续向前遍历
Current <- Current - 1
ENDWHILE
NEXT Target
ENDPROCEDURE
