Bubble sort 具有可变输入数的冒泡排序

我正在为Little Man计算机开发一个气泡排序程序，我希望它有一个可变数量的输入（比如500），之后程序将停止接收输入，并将值从最小值排序到最大值

---

请注意，在冒泡排序中应接受零作为数字。因此，如果输入为3、5、6、0，则应将其排序为0、3、5、6。

想法是将第一个输入保留为其余输入的长度。通过这种方式，您可以知道何时获取了所有值。在你的例子中：

3 5 6 0

实际输入值必须为

4 3 5 6 0

…其中4告诉我们下面有4个数据值

这意味着该程序将从以下内容开始：

     INP
     BRZ quit ; nothing to do
     STA size
     ; .... other code ....
quit HLT
size DAT 

然后，代码需要使用此

大小

初始化计数器，并获取剩余的输入

        LDA size
        SUB one
loop    STA counter
        INP ; take the next input
        ; .... process this value ....
        LDA counter ; decrement the counter
        SUB one
        BRP loop ; while no underflow: repeat
        ; ... other processing on the collected input ...
quit    HLT
counter DAT

如果有多个（可能是嵌套的）循环，比如冒泡排序，则必须管理多个计数器

应用于气泡排序 在中，您将发现一个冒泡排序的实现，其中输入需要以0结尾。这里我为您提供了该解决方案的一个变体，其中0不再用作输入终止符，而是第一个输入表示输入中后面的值数组的长度

请注意，这会使代码稍长一些，因此用于存储输入阵列的剩余空间会变小：这里只有25个邮箱可用于阵列。在标准LMC上，永远不可能存储500个输入，因为总共只有100个邮箱，而代码占用了其中一些邮箱

在算法中（加载输入后），外循环需要迭代大小-1次，而内循环每次进行迭代时需要少迭代一次（这是冒泡排序的标准原则）

#输入：104 3 2 1 0 9 8 5 6 7
LDA setfirst
STA setcurr1
磷化铟
BRZ零；无事可做
子一
STA大小；实际上少了一个
输入STA计数器1
磷化铟
setcurr1 STA阵列
LDA设置电流1
加一
STA setcurr1
LDA计数器1
子一
BRP输入
LDA尺寸
文胸
分拣STA计数器1
LDA getfirst
STA getcurr1
STA getcurr2
LDA setfirst
STA setcurr2
LDA cmpfirst
STA cmpcurr
LDA计数器1
环路STA计数器2
LDA getcurr1
加一
STA getnext1
STA getnext2
LDA设置电流2
加一
斯塔赛特下一站
getnext1 LDA阵列
cmpcurr子阵列
BRP公司
getcurr1 LDA阵列
临时工
getnext2 LDA阵列
setcurr2 STA阵列
LDA温度
setnext STA阵列
公司LDA getnext1
STA getcurr1
赛特奈特酒店
STA setcurr2
LDA cmpcurr
加一
STA cmpcurr
LDA计数器2
子一
BRP环路
LDA计数器1
十二月一日
BRP排序
LDA尺寸
输出STA计数器1
getcurr2 LDA阵列
出来
LDA getcurr2
加一
STA getcurr2
LDA计数器1
子一
BRP输出
零HLT
一个DAT 1
getfirst LDA数组
setfirst STA阵列
cmpfirst子阵列
尺寸DAT
计数器1 DAT
计数器2 DAT
温度数据
阵列数据

这是最后的代码和一些基本信息。
//基本轮廓
//1）初始化（可能为空）
//2）输入计数
//3）处理特殊情况，转到1（现在没有特殊情况）
//4）输入列表
//5）对列表进行排序（使用Bubblesort）
//6）输出列表
//7）转到1
//
//程序使用LMCe，与LMC相同，只是它有一个额外的数字。
//因此，存储单元的数量为1000，值的范围为0到9999。
//
//内存映射
//
//0–79该计划
//80-87未使用（可用于测试LMC中的排序）
//88-99常数和变量
//100–999要排序的列表。
//
//初始化（此部分为空）
//
//输入计数
//
000英寸//输入计数
001 STO 090 3090//门店数量
//
//特殊情况（本节现在为空白）
//
//输入列表
//
002 LDA 096 5096//STO
003添加095 1095//确定第一个位置
004 STO 011 3011//覆盖列表的STO指令
005增加090 1090
006 STO 092 3092//存储STO+LOC+计数以确定结束
//
//输入列表循环
007 LDA 011 5013//加载操作指令（用作计数器）
008 SUB 092 2092//
009 BRZ 016 7016//如果是最后一次计数，请转到结束输入列表
010 IN 9001//
011 DAT 0//操作指令（将输入存储在列表中）
012 LDA 011 5011
013添加098 1098//增量存储指令（到下一个列表位置）
014 STO 011 3011//更新STO指令
015 BR 007 6007//转到输入列表循环
//
//结束输入列表
//
//泡泡糖
//注：“收件人”包括在内。
//
//I=0计数–1 do（可能不包括在内）
//对于j=计数–1向下至I+1 do（可能包括在内）
//如果A[j]This is the final code and some basic information.

// Basic Outline
// 1) Initialize (may be empty)
// 2) Input Count
// 3) Handle Special Cases, GoTo 1 (will now be no special cases)
// 4) Input List
// 5) Sort the list (using Bubblesort)
// 6) Output List
// 7) GoTo 1
//
// Program uses an LMCe, same as an LMC except that it has an extra digit. 
//The number of memory cells is thus 1000 and the range of values is from 0 to 9999.
//
// Memory Map
//
// 0 – 79 the program
// 80-87 unused (may be used to test sorting in LMCs)
// 88-99 constants and variables
// 100 – 999 the list to be sorted.
//
// INITIALIZE (This section is blank)
//
// INPUT COUNT
//
000 IN 9001 // input count
001 STO 090 3090 // store count
//
// SPECIAL CASES (This section is now blank)
//
// INPUT LIST
//
002 LDA 096 5096 // STO
003 ADD 095 1095 // Determine first location
004 STO 011 3011 // Overwrite STO instruction for list
005 ADD 090 1090
006 STO 092 3092 // Store STO + LOC + Count to determine end
//
// INPUT LIST LOOP
007 LDA 011 5013 // Load manipulated instruction (using as counter)
008 SUB 092 2092 //
009 BRZ 016 7016 // If last count, go to END INPUT LIST
010 IN 9001 //
011 DAT 0 // manipulated instruction (store input in list)
012 LDA 011 5011
013 ADD 098 1098 // increment store instruction (to next list location)
014 STO 011 3011 // Update STO instruction
015 BR 007 6007 // GOTO INPUT LIST LOOP
//
// END INPUT LIST
//
// BUBBLESORT
// Note: the ‘to’ is inclusive.
//
// for I = 0 to count – 1 do (may not be inclusive)
// for j = count – 1 downto I + 1 do (may be inclusive)
// if A[j] < A[j-1]
// then exchange A[j] and A[j-1]
// end do
// end do
//
// If count < 2, then skip bubble sort
016 LDA 098 5098
017 SUB 090 2090 // 1 – count
018 BRP 061 8061 //. GO TO END I LOOP
//
// Initialize ‘I’ Counter
019 LDA 099 5099
020 STO 092 3092 // set I to zero (0)
//
// START I LOOP
//
021 LDA 090 5090
022 SUB 098 2098 // COUNT - 1
023 SUB 092 1092 // COUNT -1 – I
024 BRZ 061 7061 // if(I == count - 1) GOTO END I LOOP
//
// Initialize J
025 LDA 090 5090
026 SUB 098 2098
027 STO 093 3093 // J = Count – 1
//
// START J LOOP
//
028 LDA 092 5092 // I
029 SUB 093 2093 // I - J
030 BRP 057 8057 // If I == j, then GO END J LOOP
//
// Compare A[j] and A[j-1]
//
// Load A[j] into variable
031 LDA 097 5097 // load LDA instruction numeric code
032 ADD 095 1095 // set to LDA 500
033 ADD 093 1093 // set to LDA [500 + j] or A[j]
034 STO 039 3039 // reset instruction
035 SUB 098 2098 // set to LDA [500 + j – 1] or A[j-1]
036 STO 037 3037 // reset instruction
//
// Load and compare A[j] and A[j-1]
037 DAT 0 // load A[j-1] (instruction is manipulated)
038 STO 088 3088
039 DAT 0 // load A[j] (instruction is manipulated)
040 STO 089 3089
041 SUB 088 2088 // A[j] – A[j-1] (swap if not positive)
042 BRP 053 8053 // GOTO DECREMENT J
//
// swap the variables
//
// set up the STO variables
043 LDA 096 5096 // load STO instruction code
044 ADD 095 1095 // set to STO 500
045 ADD 093 1093 // set to STO [500 + j]
046 STO 052 3052 // reset instruction
047 SUB 098 2098 // set to STO [500 + j – 1]
048 STO 050 3050 // reset instruction
//
// do the swap (no need for a variable since they are already stored)
049 LDA 089 5089 // load A[j]
050 DAT 0 // Store in A[j-1] (instruction is manipulated)
051 LDA 088 5088 // load A[j-1]
052 DAT 0 // Store in A[j] (instruction is manipulated)
//
// DECREMENT J
//
053 LDA 093 5093
054 SUB 098 2098
055 STO 093 3093 // J = J – 1
056 BR 028 6028 // GOTO START J LOOP
//
// END J LOOP
//
// Increment I
057 LDA 092 5092
058 ADD 098 1098
059 STO 092 3092 // I = I + 1
060 BR 021 6021 // GOTO START I LOOP
//
// END I LOOP (End Bubblesort)
//
// OUTPUT COUNT
//
061 LDA 090 5090 // Count
062 OUT 9002
//
// OUTPUT LIST (now sorted)
// Initialize
063 LDA 097 5097
064 ADD 095 1095 // LDA + LOC
065 STO 071 3071 // set up instruction
066 ADD 090 1090 // LDA + LOC + Count
067 STO 092 3092 // store unreachable instruction
//
// OUTPUT LIST LOOP
068 LDA 071 5071 // load manipulated instruction (used as counter)
069 SUB 092 2092
070 BRZ 077 7077 // GOTO END OUTPUT LOOP
071 DAT 0 // manipulated output
072 OUT 9002
073 LDA 071 5071
074 ADD 098 1098
075 STO 071 3071 // increment manipulated instruction
076 BR 068 6028 // GOTO OUTPUT LIST LOOP
//
// END OUTPUT LOOP
077 BR 0 6000 // Branch to top of loop (embedded)
//
// End of program
078 HLT 0 // (Should never hit this instruction)
//
// Variables
088 DAT 0 // A[j-1] value (also used for swapping)
089 DAT 0 // A[j] value (also used for swapping)
//
090 DAT 0 // count variable (input and output)
091 DAT 0 // unused
092 DAT 0 // ‘I’ counter
093 DAT 0 // ‘j’ counter
//
// Constants
094 DAT 0 // unused
095 DAT 500 // initial list location
096 DAT 3000 // STO instruction
097 DAT 5000 // LDA instruction
098 DAT 1 // one (constant)
099 DAT 0 // zero (constant)