微机原理-实验一-汇编语言-冒泡排序
微机原理实验报告冒泡法对数据排序8页
微机原理实验报告冒泡法对数据排序8页
实验目的：通过对冒泡法进行实现，了解算法的实际应用，并且掌握编程语言的基本
技巧。
实验原理：
冒泡排序是一种简单的排序方法，它的基本思想就是通过不断交换相邻的元素，将较
小的元素交换到前面，较大的元素交换到后面，从而将整个数列按从小到大（或从大到小）的顺序进行排列。
实验步骤：
（1）首先，输入需要排序的数据，将这些数据依次存储在数组中。
（2）然后，对这个数组进行冒泡排序操作。
具体的操作是：从数组的第一个元素开始，依次比较相邻两个元素的大小关系，如果后面的元素小于前面的元素，就将它们交换位置，直到将整个数组排列好为止。
（3）最后，输出排列好的数据。
实验代码：
2. 对这个数组进行冒泡排序操作。
实验结果：
输入需要排序的 10 个整数：
5 2 4 7 9 1 3 8
6 0
冒泡排序后的结果为：
0 1 2 3 4 5 6 7 8 9
实验分析：
通过本次实验，我们成功地实现了冒泡法对数据排序的操作。
在程序的实现过程中，
我们利用了C语言中的数组和循环结构等基本语言要素，完成了对数组中的数据进行排序
的操作。
通过本次实验，我们深入了解了算法的实际应用，掌握了编程语言的基本技巧，
对于今后的学习和实践具有重要的意义。
汇编冒泡法排序
汇编实验报告实验题目：从键盘输入任意5个2位有符号十进制数，采用“冒泡法”进行升序排序，输出排序后的结果，并输出排序次数。
实验设计：实验要求用16位机的汇编语言完成，键盘上输入的的数据最终都会以ASCII码形式接受，输出也要求用ASCII码，因而我决定设计专门负责输入和输出的两个子程序。
但是由于要求输入的是有符号的而且是长度不一定不确定的十进制数，用一个子程序直接在输入时转换成二进制会比较麻烦，因而决定可以先以字符串的形式接受来自用户的数据，这样可以以最自由的形式接受数据，不仅数据长度问题可以解决，带不带‘+’‘-’符号也可以识别，而且方便查错。
排序的主要部分是比较简单的，学C的时候已经了解，况且数据结构课又重复了一遍，因而本次实验主要需要解决的还是输入输出、以及数据的转化问题。
我的程序结构比较简单，主要包含几个子程序：GET : 调用10号模块接收一串字符,放进缓存dataEXDTB:解析缓存中的符号数据,转化为二进制并存入数组ansEXBTD:对从BX传过来的二进制数解析,并在屏幕上输出相应的十进制数,无运算结果程序:DATAS SEGMENTDATA DB 21 DUP('$')ANS DW 10 DUP(0)TES DB 'RUN HRER','$'LEN DW 0TMP DW 0SIG DW 00HSTA DW 00H ;STA ANS[STA] IS DIGENT DB 0DH,0AH,'$'RNM DB 'READ 5 DIGITALS',0AH,0DH,'$'PRIT DB 'PAIXU:',0AH,0DH,'$'FINSH DB 'NEW ORDER:','$'EORR DB 'INPUT ERROR!',0AH,0DH,'$'CISHU DB 'EXCHANGE TIME:',0DH,0AH,'$'CIS DW 0EXIT DB 'ENTER A NUMBER TO EXIT',0AH,0DH,'$'DATAS ENDSSTACK SEGMENTTOPE DW 300H DUP(0)STACK ENDSCODES SEGMENTASSUME CS:CODES, DS:DATAS,SS:STACKSTART: ;先跳过写在开头的子程序MOV AX,DATASMOV DS,AXMOV AX,STACKMOV SS,AXMOV SP,00HJMP SART ;AH=09 OUPUT AH=10 INPUT，前面注意有两个字节没用从ds:dx+2开始才是 ;第一个是输入及字符数ENTE PROC ;ENTE DISPLAY '/N' ON THE SCREENPUSH AXPUSH DXMOV AX,OFFSET ENTMOV DX,AXMOV AH,09HINT 21HPOP DXPOP AXRETENTE ENDPGET PROC ;PROC GET READ A TWO BIT DIGITAL FROM USCERPUSH AX ;;DX HAS ADDRESSPUSH DXMOV DX,OFFSET DATAMOV AH,0AH ;GET A LINE OF NUMBERINT 21H;CALL ENTEPOP DXPOP AXRETGET ENDPEXDTB PROC ;PROC EXCHANGE SIGNED DIGITAL TO BINARYPUSH AXPUSH BXPUSH CXPUSH DX ;USE DX TO STORE ANS;ANS[STA] HAS RESULT XOR DX,DXXOR CX,CXMOV BX,OFFSET DATAINC BX ;DS:DX+1 IS THE NUMBER OF INPUTED CHAR MOV CL,[BX] ;cl HAS LENGTHXOR CH,CHINC BX ;NOW BX COME TO FIRST CHAR INPUTEDMOV AL,[BX]CMP AL,'-' ;TO CHECK IF IT IS SIGNJNZ POST ;WITHOUT '-',THAT WILL BE POSTIVEMOV WORD PTR[SIG], 0001H ;SET SIG 0001H IF NEGETIVE JMP SIGNEDPOST:MOV SIG,WORD PTR 0000H ;SET POSTIVECMP AL,'+' ;IF IT HAS '+',IGNORE ITJNE PASSSIGNED:INC BXSUB CX,01HJMP STLOP ;PASS THE SIGN + -PASS: ;DIRECTLY TO NUMBERSCMP AL,'0' ;IF IT IS NUMBERJL NOTHINGCMP AL,'9'JG NOTHINGMOV DL,ALSUB DL,'0'CMP CL,1JE POSTYSUB CX,01HSTLOP:MAINLOOP:MOV AL,[BX]SUB AL,'0'JS NOTHING ;JUMP IF AL-'0'< 0 , ILLEAGLE INPUT CMP AL,09H ;JUMP IF AL-'9'> 0 ,JG NOTHINGMOV DH,DL ;SHIFT DL TO TIMES 10SHL DH,01H ;SHIFT 2 TIMES 4SHL DH,01H ;DL=DL*4+DL=5*DLADD DL,DHSHL DL,01H ;DL=5*DL*2=10*DLADD DL,ALINC BXLOOP MAINLOOPTEST SIG,0001HJZ POSTY ;JUMP TO AVOID -DXNEG DLPOSTY:MOV BX,OFFSET ANSADD BX,STAMOV AL,DLCBWMOV [BX],AXJMP DONENOTHING: ;IF NOT NUMBER , RETURN 0MOV DX,OFFSET EORRMOV AH,09HINT 21HMOV BX,OFFSET ANSADD BX,STAMOV [BX],WORD PTR 0001HDONE:CALL ENTEPOP CXPOP BXPOP AXRETEXDTB ENDPEXBTD PROC ;PROC EXCHANGE BINARY NUMBER IN BX TO DIGITAL PUSH AXPUSH BXPUSH CXPUSH DXCALL ENTE ;DISPLAY '/N'TEST BX,8000HJZ POSTVMOV DL,'-'MOV AH,02HINT 21HNEG BX ;EXCHANGE TO POSTIVEPOSTV:MOV CX,1111HPUSH CXMOV AX,BXCWDMOV BX,10MLOOP:DIV BX ;DIV 10PUSH DX ;PUSH BX MOD 10CWDADD AX,00HJNZ MLOOPDSLOOP: ;DISPLAY NUMPOP DXCMP DX,1111HJE FINISHADD DL,'0'MOV AH,02HINT 21HJMP DSLOOPFINISH:;CALL ENTEPOP DXPOP CXPOP BXPOP AXRETEXBTD ENDPSART:MOV DX,OFFSET PRITMOV AH,09HINT 21HMOV DX,OFFSET RNMMOV AH,09INT 21HMOV CX,05HMOV WORD PTR[STA],0000HGETLOOP:CALL GET ；读入符号数CALL EXDTB ;转为二进制ADD WORD PTR[STA],0002H;存入数组ans LOOP GETLOOPMOV WORD PTR[CIS],00HARRAGE: ；排序MOV CX,05HSUB CX,0001HMOV BX,OFFSET ANSADD BX,CXADD BX,CXLOOP1:MOV TMP,CXPUSH BXLOOP2:MOV AX,WORD PTR[BX]SUB BX,0002HMOV DX,WORD PTR[BX]CMP AX,DXJNS BIGGERINC WORD PTR[CIS]MOV WORD PTR[BX],AXMOV 02H[BX],DXBIGGER:SUB WORD PTR[TMP],0001H JNZ LOOP2POP BXLOOP LOOP1WRITE: ；输出排好序的数MOV DX,OFFSET FINSHMOV AH,09HINT 21HMOV CX,05MOV WORD PTR[STA],0000HMOV BX,OFFSET ANSLOOPWR:PUSH BXADD BX,STAMOV DX,[BX]MOV BX,DXCALL EXBTDPOP BXADD WORD PTR[STA],0002HLOOP LOOPWRCALL ENTEMOV DX,OFFSET CISHUMOV AH,09HINT 21HMOV BX,[CIS]CALL EXBTDCALL ENTEMOV DX,OFFSET EXITMOV AH,09HINT 21HCALL GETMOV AX,4C00HINT 21HCODES ENDSEND START问题及调试:主要问题是数据的转化，当我们用C写程序时，直接可以用%开头的格式命令进行特定类型的数据输入输出，但是用汇编时就没有那么好办了，输入的时候要识别数据，输出也要转化数据。
微机原理实验报告-冒泡排序
一、实验目的（1）学习汇编语言循环结构语句的特点，重点掌握冒泡排序的方法。
（2）理解并掌握各种指令的功能，编写完整的汇编源程序。
（3）进一步熟悉DEBUG的调试命令，运用DEBUG进行调试汇编语言程序。
二、实验内容及要求（1）实验内容：从键盘输入五个有符号数，用冒泡排序法将其按从小到大的顺序排序。
（2）实验要求：①编制程序，对这组数进行排序并输出原数据及排序后的数据；②利用DEBUG调试工具，用D0命令，查看排序前后内存数据的变化；③去掉最大值和最小值，求出其余值的平均值，输出最大值、最小值和平均值；④用压栈PUSH和出栈POP指令，将平均值按位逐个输出；⑤将平均值转化为二进制串，并将这组二进制串输出；⑥所有数据输出前要用字符串的输出指令进行输出提示，所有数据结果能清晰显示。
三、程序流程图（1）主程序:MAIN是（2）冒泡排序子程序: SORT否是是四、程序清单NAME BUBBLE_SORTDATA SEGMENTARRAY DW 5 DUP() ;输入数据的存储单元COUNT DW 5TWO DW 2FLAG1 DW 0 ;判断符号标志FLAG2 DB 0 ;判断首位是否为零的标志FAULT DW -1 ;判断出错标志CR DB 0DH,0AH,'$'STR1 DB 'Please input five numbers seperated with space and finished with Enter:','$'STR2 DB 'The original numbers:','$'STR3 DB 'The sorted numbers:','$'STR4 DB 'The Min:','$'STR5 DB 'The Max:','$'STR6 DB 'The Average:','$'STR7 DB 'The binary system of the average :','$'STR8 DB 'Input error!Please input again!''$'DATA ENDSCODE SEGMENTMAIN PROC FARASSUME CS:CODE,DS:DATA,ES:DATASTART: PUSH DSAND AX,0PUSH AXMOV AX,DATAMOV DS,AXLEA DX,STR1MOV AH,09H ;9号DOS功能调用，提示输入数据INT 21HCALL CRLF ;回车换行REIN: CALL INPUT ;调用INPUT子程序，输入原始数据CMP AX,FAULT ;判断是否出错，JE REIN ;出错则重新输入LEA DX,STR2MOV AH,09H ;9号DOS功能调用，提示输出原始数据INT 21HCALL OUTPUT ;调用OUTPUT子程序，输出原始数据CALL SORT ;调用SORT子程序，进行冒泡排序LEA DX,STR3MOV AH,09H ;9号DOS功能调用，提示输出排序后的数据 INT 21HCALL OUTPUT ;调用OUTPUT子程序，输出排序后的数据AND SI,0AND BX,0MOV BX,ARRAY[SI] ;将最小值存入BXLEA DX,STR4MOV AH,09H ;9号DOS功能调用，提示输出数据的最小值INT 21HCALL ONE ;调用ONE子程序，输出最小值CALL CRLFLEA DX,STR5MOV AH,09H ;9号DOS功能调用，提示输出排序后的最大值INT 21HMOV BX,ARRAY[SI+8] ;将最大值存入BXCALL ONE ;调用ONE子程序，输出最大值CALL CRLFLEA DX,STR6MOV AH,09H ;9号DOS功能调用，提示输出平均值INT 21HAND DX,0MOV AX,ARRAY[SI+2] ;将去掉最大最小值的其余各数之和存入AXADD AX,ARRAY[SI+4]ADC AX,ARRAY[SI+6]MOV CX,COUNT ;计数器CX=5DEC CX ;CX←CX-1DEC CXDIV CX ;字除法，余数存入AXMOV BX,AX ;将余下各数的平均值存入BXCALL ONE ;调用ONE子程序，输出去掉最大最小值的其余数平均值 CALL CRLFLEA DX,STR6MOV AH,09H ;9号DOS功能调用，提示输出平均值的二进制串MOV CX,16 ;16位二进制串，计数器初始值为16LL1: AND DX,0DIV TWOPUSH DXLOOP LL1MOV CX,16LL2: POP DXADD DL,30H ;将DL中的数进行ASCII码转换MOV AH,2 ;2号DOS功能调用，输出字符“0”或“1”INT 21HLOOP LL2MOV AH,4CHINT 21H ;4C号功能调用，返回DOSMAIN ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：CRLF功能：回车和换行;--------------------------------------------------------------------------------------------------------------------------------CRLF PROCLEA DX,CRMOV AH,09HINT 21HRETCRLF ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：INPUT功能：输入一组数据;--------------------------------------------------------------------------------------------------------------------------------INPUT PROCMOV CX,COUNT ;计数器CX=5AND SI,0NEXT1: CALL DTB ;调用DTB子程序，将输入转换为二进制数DEC CX ;CX←CX-1CMP DL,20H ;判断输入字符是否为空格符JE STOCMP DL,0DH ;判断输入字符是否为换行符JE EXIT2CALL CRLFERROR: LEA DX,STR8MOV AH,09H ;9号DOS功能调用，提示输入不合法INT 21HCALL CRLFMOV AX,FAULT ;以AX中的值作为出错标志JMP EXIT3STO: MOV ARRAY[SI],BX ;是空格符，将BX中的二进制数存入存储单元ADD SI,2JMP NEXT1EXIT2: MOV ARRAY[SI],BX ;是换行符，将BX中的二进制数存入存储单元CALL CRLFEXIT3: RETINPUT ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：DTB功能：将键盘输入的十进制数转换为二进制数形式存入BX;--------------------------------------------------------------------------------------------------------------------------------DTB PROCAND BX,0AND FLAG1,0 ;符号标志，0为正，1为负CHAR: MOV AH,01H ;1号DOS功能调用，输入一个字符，存入ALINT 21HMOV DL,ALCMP AL,2DH ;判断输入字符是否为负号"-"JNZ NEXT2MOV FLAG1,1 ;是负数，将符号标志FLAG1置1JMP CHARNEXT2: SUB AL,30H ;判断输入字符是否在0-9之间JL NEXT3CMP AL,09HJG NEXT3CBWXCHG AX,BX ;输入字符在0-9之间，将BX中的数乘以10MOV CX,10MUL CXXCHG AX,BXADD BX,AX ;将BX中的数与新输入的数相加JMP CHARNEXT3: CMP FLAG1,1 ;根据符号标志判断输入是否为负JNZ EXIT1NEG BX ;对BX中的数求补EXIT1: RETDTB ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：OUTPUT功能：输出一组数据;--------------------------------------------------------------------------------------------------------------------------------OUTPUT PROCMOV DI,COUNT ;计数器DI=5AND SI,0GO1: MOV BX,ARRAY[SI] ;将存储单元的第一组数据存入BXTEST BX,8000H ;判断正负JZ GO2MOV DL,2DHMOV AH,02H ;2号DOS功能调用，输出负号"-"INT 21HNEG BXGO2: CALL ONE ;调用ONE子程序，将BX中二进制数转换为十进制数输出 MOV DL,20HMOV AH,02H ;2号DOS功能调用，输出空格符INT 21HADD SI,2 ;指针指向下一数据DEC DI ;DI←DI-1JNZ GO1 ;计数器DI不为零，继续循环CALL CRLFRETOUTPUT ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：ONE功能：将BX中的的二进制数转换为十进制数,由高到低各位依次输出;--------------------------------------------------------------------------------------------------------------------------------ONE PROCPUSH CXPUSH SIPUSH DIMOV CX,10000 ;除数存入CXCALL BTDMOV CX,1000CALL BTDMOV CX,100CALL BTDMOV CX,10CALL BTDMOV CX,1CALL BTDADD DL,FLAG2CMP DL,30H ;与"0"的ASCII码比较，判断该数是否为"0"JNE QUIT3MOV AH,02H ;2号DOS功能调用，输出"0"INT 21HQUIT3: POP DIPOP SIPOP CXPOP BXAND FLAG2,0 ;将首位标志FLAG2重新置0RETONE ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：BTD功能：将BX中的二进制数转换为一个十进制数输出;--------------------------------------------------------------------------------------------------------------------------------BTD PROCMOV AX,BXAND DX,0DIV CX ;字除法，商值存入AX,余数存入DXMOV BX,DX ;余数存入BXMOV DL,ALADD DL,30H ;对DL中的数进行ASCII码转换CMP FLAG2,0 ;判断是否为首位数据JNE QUIT1CMP DL,30H ;是首位则判断是否为"0"JE QUIT2 ;是"0"则不输出MOV FLAG2,1 ;不是"0"将首位标志置1QUIT1: MOV AH,02H ;2号DOS功能调用，输出一位十进制数INT 21HQUIT2: RETBTD ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：SORT功能：冒泡排序;--------------------------------------------------------------------------------------------------------------------------------SORT PROCCLDMOV CX,COUNT ;初始化计数器CXDEC CX ;CX=4LOO1: MOV DI,CX ;CX中的数存入DIAND SI,0LOO2: MOV AX,ARRAY[SI]CMP AX,ARRAY[SI+2] ;相邻两数进行比较JL LOO3XCHG AX,ARRAY[SI+2] ;前一数较大则进行数据交换MOV ARRAY[SI],AXLOO3: ADD SI,2 ;前一数较小，则进行下一组比较LOOP LOO2 ;CX=0,停止内循环MOV CX,DI ;还原计数器CX的值LOOP LOO1 ;CX=0,停止外循环RETSORT ENDP;--------------------------------------------------------------------------------------------------------------------------------CODE ENDSEND START五、运行结果（1）对300,250,280,240,260五个数进行冒泡排序，运行结果如下：（2）对-1,2,54，-38,43五个数进行冒泡排序，运行结果如下（1）当输入不合法时，出现错误提示：（4）当输入数据不足5个时程序自动补0：六、心得体会在本次汇编语言程序设计实验中，我们学习了汇编语言的循环结构，并对冒泡排序法进行了汇编程序设计，我首先编写了对给定数据进行冒泡排序的算法设计，这有助于我熟悉冒泡排序的逻辑结构，理清设计思路。
实验报告_冒泡排序法(3篇)
第1篇一、实验目的1. 理解冒泡排序算法的基本原理和操作步骤。
2. 掌握冒泡排序算法的实现方法。
3. 分析冒泡排序算法的时间复杂度和空间复杂度。
4. 通过实验验证冒泡排序算法的效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验原理冒泡排序是一种简单的排序算法，其基本思想是通过多次比较和交换相邻元素，将待排序的序列变为有序序列。
冒泡排序算法的基本步骤如下：1. 从第一个元素开始，相邻的两个元素进行比较，如果它们的顺序错误（即第一个元素大于第二个元素），则交换它们的位置。
2. 重复步骤1，对相邻的元素进行比较和交换，直到整个序列的最后一个元素。
3. 第一轮排序完成后，最大的元素被放置在序列的最后一个位置。
4. 从第一个元素开始，对剩余的元素重复步骤1和步骤2，直到序列的倒数第二个元素。
5. 重复步骤3和步骤4，直到整个序列有序。
四、实验步骤1. 编写冒泡排序算法的C++代码，实现上述算法步骤。
2. 在主函数中创建一个待排序的数组。
3. 调用冒泡排序函数对数组进行排序。
4. 输出排序前后的数组，验证排序结果。
五、实验代码```cppinclude <iostream>using namespace std;// 冒泡排序函数void bubbleSort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) {// 交换相邻元素int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}// 打印数组函数void printArray(int arr[], int n) {for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;}int main() {// 创建待排序的数组int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);// 打印排序前的数组cout << "排序前的数组：\n";printArray(arr, n);// 调用冒泡排序函数bubbleSort(arr, n);// 打印排序后的数组cout << "排序后的数组：\n";printArray(arr, n);return 0;}```六、实验结果与分析1. 运行实验程序，输出排序前后的数组，验证排序结果是否正确。
汇编语言实现整数冒泡排序
第三次实验报告1.实现正整数的冒泡排序，要求有输入与输出。
实验源程序;LT413.ASM.model small.stack.datacount = 10array dw count dup(0)wtemp dw ?flg db 0.code.startupmov cx,countmov bx,offset arrayagaini: call readmov [bx],axinc bxinc bxcall dpcrlfiloop againi;;mov cx,countdec cxoutlp:mov flg,0mov dx,cxmov bx,offset arrayinlp: mov ax,[bx]cmp ax,[bx+2]jna nextxchg ax,[bx+2]mov flg,1mov [bx],axnext: inc bxinc bxjnz inlpcmp flg,0jz fxwloop outlp;;fxw:mov cx,countmov bx,offset array againo: mov ax,[bx]mov wtemp,axcall writeinc bxinc bxcall dpcrlfoloop againo.exit 0read procpush bxpush cxpush dxxor bx,bxxor cx,cxmov ah,1int 21hcmp al,'+'jz read1cmp al,'-'jnz read2mov cx,-1read1: mov ah,1int 21hread2: cmp al,'0'jb read3cmp al,'9'ja read3sub al,30hshl bx,1mov dx,bxshl bx,1add bx,dx;mov ah,0add bx,axjmp read1read3: cmp cx,0jz read4neg bxread4: mov ax,bxpop dxpop cxpop bxretread endp dpcrlfi procpush axpush dxmov ah,2mov dl,0dhint 21hmov ah,2mov dl,0ahint 21hpop dxpop axretdpcrlfi endpwrite procpush axpush bxpush dxmov ax,wtemptest ax,axjnz write1mov dl,'0'mov ah,2int 21hjmp write5 write1: jns write2 mov bx,axmov dl,'-'mov ah,2int 21hmov ax,bxneg axwrite2: mov bx,10push bxwrite3: cmp ax,0jz write4sub dx,dxdiv bxadd dl,30hpush dxjmp write3write4: pop dxcmp dl,10je write5mov ah,2int 21hjmp write4write5: pop dxpop bxpop axretwrite endpdpcrlfo procpush axpush dxmov ah,2mov dl,0dhint 21hmov ah,2mov dl,0ahint 21hpop dxpop axretdpcrlfo endpend实验结果：2.编制一个子程序把一个16位二进制数用十六进制的形式在屏幕上显示出来，分别运用如下三种参数传递方式，并用一个主程序验证它（1）采用AX寄存器传递这个16位的二进制数（2）采用wordTEMP变量传递这个16为二进制数（3）采用堆栈方法传递这个16位二进制数实验源程序：.model small.stack.datastring1 db 'Mean1 use register :','$'string2 db 'Mean2 use variable :','$'string3 db 'Mean3 use stack :','$'string4 db 0dh,0ah,'$'mydata dw 1992hwordTEMP dw ?.code.startup;AX方式mov dx,offset string1;mov ah,9;int 21h;mov ax,word ptr mydata;call chan1;;变量方式push axmov dx,offset string4;mov ah,09h;int 21h;mov dx,offset string2;mov ah,09h;int 21h;pop axmov word ptr wordTEMP,ax;call chan2;;栈方式push axmov dx,offset string4;mov ah,09h;int 21h;mov dx,offset string3;mov ah,09h;int 21h;pop axpush ax;call chan3;pop ax;.exit 0chan1 procpush ax;push bx;mov bl,al;mov al,ah;call ALdisp;mov al,bl;call ALdisp;pop bx;pop ax;retchan1 endpchan2 proc;wordTEMP传递push ax;push bx;mov bl,al;mov al,ah;call ALdisp;mov al,bl;call ALdisp;pop ax;retchan2 endpchan3 proc;栈传递push bp;mov bp,sp;push ax;push bx;mov ax,[bp+4];mov bl,al;mov al,ah;call ALdisp;mov al,bl;call ALdisp;pop bx;pop ax;pop bp;retchan3 endpALdisp procpush axpush cxpush dxpush axmov dl,almov cl,4shr dl,clor dl,30hcmp dl,39hjbe aldisp1add dl,7aldisp1: mov ah,2 int 21hpop dxand dl,0fhor dl,30hcmp dl,39hjbe aldisp2add dl,7aldisp2: mov ah,2 int 21hpop cxpop axretALdisp endpend实验结果：。
川大微机上机实验报告（冒泡排序法）
川⼤微机上机实验报告（冒泡排序法）上机⽬的：1、了解并逐步熟悉汇编语⾔的编辑⽅法及特点.2、复习8088汇编语⾔的段结构、常⽤的指令与伪指令、存储空间的分配等。
3、掌握汇编语⾔的编辑、汇编及连接的过程。
4、了解并逐步掌握运⽤DEBUG进⾏调试汇编语⾔程序。
5、掌握循环结构程序的设计编程。
上机内容：⽤冒泡法对⼀组数300，250，280，240，260按从⼩到⼤的顺序排列。
提⽰：1、⽤冒泡的⽅法对⼀组数据元素排序，它的基本⽅法是：将相邻的两个元素通过⽐较进⾏排序，通过多次，多遍的邻元素排序，实现整个⼀组数的排序。
2、对于5（N）个元素，整个排序通过4遍（=N-1）邻元素排序完成。
每⼀遍的排序由若⼲次邻元素的排序组成。
3、4遍排序中，邻元素的排序依次为4，3，2，1遍。
完成第⼀遍排序后，最⼤数沉底，已经到达它应占据的位置，不需要参加下⼀遍的排序。
外循环的次数为CX=4次(N-1)，内循环的次数为4，3，2，1(DEC CX)思考如何输⼊任意五个数，五个数可以有⼀位数，⼆位数，三位数，四位数，五位数，混合输⼊⽐较⼤⼩；2、对这组数⽤冒泡法进⾏排序，并输出原始数据及排序后数据，两两数据之间⽤空格分隔；3、利⽤DEBUG调试⼯具，⽤D0命令，查看排序前后，内存数据的变化，以及会⽤调试命令查看程序运算中寄存器中的值；4、去掉最⼤和最⼩的两个值，求出其余值的平均值，并输出最⼤值，最⼩值和平均值；5、⽤压栈PUSH和出栈POP指令“先进后出”的特点，设计算法将平7、设计程序要有模块化的思想，⽤⼦程序实现不同的功能；8、所有数据输出前要⽤字符串的输出指令，进⾏输出提⽰（如：zui dazhi shi : 300等），所有数据结果能清晰地显⽰在电脑屏幕上。
程序流程图如下：程序清单：DATAS SEGMENTSHU2 DB 4,?,3 DUP(?)SHU3 DB 4,?,3 DUP(?)SHU4 DB 4,?,3 DUP(?)SHU5 DB 4,?,3 DUP(?)AVER DB 3 DUP(?)SHUCHU DB 'PAI XU HOU DE SHU JU SHUN XU SHI',':','$'MAX DB 'ZUI DA ZHI SHI',':','$'MIN DB 'ZUI XIAO ZHI SHI',':','$'AVERAGE DB 'PING JUN ZHI SHI',':','$'CHUSHU DB 100,10HE DW ?STR1 DB 16 DUP(30H)STR2 DB 'PING JUN ZHI DE ER JIN ZHI CHUAN SHU CHU',':','$' DATAS ENDS CODES SEGMENTASSUME CS:CODES,DS:DATASSTART: MOV AX,DATASMOV DS,AXMOV ES,AXLEA DX,SHURU;显⽰QING SHU RU 5 GE SHU JU：MOV AH,9INT 21HMOV CX,5;输⼊五个数字MOV SI,0INPUT: LEA DX,[SHU1+SI];输⼊要排序的原始数据MOV AH,10INT 21HMOV DL,10;输⼊后换⾏MOV AH,2INT 21HADD SI,5;指针加5，指向下⼀个变量LOOP INPUTCLDMOV CX,4;设定排序外循环次数L1: MOV BP,0PX: PUSH CXMOV CX,3LEA SI,[SHU1+BP+2];逐位⽐较两个数⼤⼩LEA DI,[SHU1+BP+7]REPZ CMPSBJB L2;如果⼩于直接⽐较下⼀个数，否则两个数对换位置MOV CX,3Jh: MOV AL,SHU1[BP+2]XCHG AL,SHU1[BP+7]；将两个字节对换位置，循环3次即完成这两个数的交换XCHG AL,SHU1[BP+2]INC BPLOOP JhSUB BP,3L2: ADD BP,5;指向后⾯两个数字POP CXLOOP PXPOP CX;外循环次数出栈LOOP L1LEA DX,SHUCHU;输出字符串'PAI XU HOU DE SHU JU SHUN XU SHI：' MOV AH,9 INT 21HMOV CX,5MOV SI,2OUTPUT:PUSH CX;计数器⼊栈实现循环嵌套MOV CX,3L3: MOV AL,[SHU1+SI];输出排序后的5个数字MOV DL,ALMOV AH,2INT 21HINC SILOOP L3MOV DL,2CHMOV AH,2INT 21HPOP CX;计数器出栈LOOP OUTPUTMOV DL,10MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,MAX;输出字符串'ZUI DA ZHI SHI：' MOV AH,9INT 21HMOV SI,2L4: MOV DL,[SHU5+SI];输出最⼤值MOV AH,2INT 21HINC SILOOP L4MOV DL,10;换⾏MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,MIN;输出字符串'ZUI XIAO ZHI SHI：' MOV AH,9INT 21HMOV CX,3MOV SI,2L5: MOV DL,[SHU1+SI];输出最⼩值MOV AH,2INT 21HINC SILOOP L5MOV DL,10INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,AVERAGE;输出字符串'PING JUN ZHI SHI：'MOV AH,9INT 21HMOV CX,3MOV BX,10;除数10MOV SI,2AD: MOV DX,0MOV AH,0PUSH CXMOV CX,3ZH: MOV AL,[SHU2+SI];将⼗进制数转换为⼆进制数，为后⾯求平均值做准备 SUB AL,30H PUSH AXMOV AX,DXMUL BXPOP AXADD DX,AXINC SILOOP ZH;执⾏3次完成3个⼗进制数的转换ADD SI,2POP CXADD HE,DX;将DX的数放在HE中LOOP AD;循环后得到三个⼗进制数转换为⼆进制数之后的相加和MOV DX,HE;MOV AX,DXXOR DX,DXMOV BX,3DIV BX;除3取平均值,结果将商放在AX中，余数放在DX中MOV BX,AX;给BX赋值平均数，然后将BX中表⽰的⼗进制数转换为对应的字符串DIV CHUSHU;除100取最⾼位ADD AL,30H;转换为ASCII码DIV [CHUSHU+1];除10取⼗位ADD AL,30HADD AH,30H;余数就是个位MOV [AVER+1],ALMOV [AVER+2],AHMOV CX,3MOV SI,0L6: MOV DL,[AVER+SI];输出平均值MOV AH,2INT 21HINC SILOOP L6MOV DL,10MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,STR2 ;输出字符串'PING JUN ZHI DE ER JIN ZHI CHUAN SHU CHU：’ MOV AH,9 INT 21HMOV CX,16MOV SI,0L7: RCL BX,1;将平均数转换为⼆进制串JNC L8ADD [STR1+SI],1；如果不为0就将其加1变成1的ASCII码值L8: MOV DL,[STR1+SI];将⼆进制串逐个输出MOV AH,2INT 21HINC SILOOP L7MOV AH,4CHINT 21H⼼得体会：本次实验编程⽐较复杂，在编这个程序之前⾃⼰先将前⾯三个练习编了⼀下，然后参考了书上的⼀个冒泡排序法的程序，之后才开始动⼿编该程序。
微机原理及接口技术实验——冒泡法
微机原理及接口技术实验——冒泡法冒泡排序是一种简单的排序算法，其基本思想是通过重复比较相邻的两个元素，并将较大的元素交换到右侧，从而将最大的元素逐渐"冒泡"到最右侧。
这种算法得名于每次比较时较大元素"冒泡"到右侧的过程。
冒泡排序算法的步骤如下：1.比较相邻的两个元素。
如果第一个元素大于第二个元素，则交换它们的位置。
2.对每一对相邻元素进行同样的操作，从左往右依次进行，这样一轮比较下来，最大的元素将会移动到最右侧。
3.重复上述步骤，每次比较的次数减1，直到所有元素都排好序。
下面是一个使用冒泡排序算法的示例程序：```pythondef bubble_sort(arr):n = len(arr)for i in range(n-1):for j in range(n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]arr = [64, 34, 25, 12, 22, 11, 90]bubble_sort(arr)print(arr)```在上述示例程序中，我们定义了一个名为`bubble_sort`的函数，该函数接受一个列表作为参数，并对列表进行冒泡排序。
在外层循环中，我们迭代n-1次，其中n为列表的长度。
在内层循环中，我们通过比较相邻元素并交换它们的位置，将较大的元素"冒泡"到右侧。
通过多次迭代，最终实现将所有元素按从小到大的顺序排列。
除了基本的冒泡排序算法，我们还可以对其进行一些改进，以提升排序的效率。
例如，我们可以设置一个标志位`flag`来记录本轮是否进行了元素的交换。
如果本轮没有进行交换，说明列表已经排好序，可以提前结束循环。
这样可以减少无意义的比较操作，提高效率。
冒泡排序算法的时间复杂度为O(n^2)，其中n为列表的长度。
在最坏情况下，即列表本身为逆序，需要进行n*(n-1)/2次比较和交换操作。
微机原理实验报告冒泡法对数据排序
实验内容:用“冒泡“法对一组数300,250,280,240,260,按从小到大的顺序排列。
实验要求:1、编制程序,对这组数进行排序,并输出原数据及排序后数据;2、利用DEBUG调试工具,用D0命令,查瞧排序前后,内存数据的变化;3、去掉最大与最小的两个值,求出其余值的平均值,并输出最大值,最小值与平均值;4、用学过的压栈PUSH与出栈POP指令,将平均值按位逐个输出(即输出263);5.将平均值263转化为二进制串,并将这组二进制串输出。
6、所有数据输出前要用字符串的输出指令,进行输出提示(如:zui da zhi shi : 300等),所有数据结果能清晰地显示在屏幕上。
程序代码:DATA SEGMENT ;定义数据段DT1 DW 300,250,280,240,260DT2 DB 'what five data input is',0DH,0AH,'$'DT3 DB 'what after rank is',0DH,0AH,'$'DT4 DB 'The max is',0DH,0AH,'$'DT5 DB 'The min is',0DH,0AH,'$'DT6 DB 'The average is',0DH,0AH,'$'DT7 DB 'show you the average one by one',0DH,0AH,'$'DT8 DB 'show you the average in binary form',0DH,0AH,'$'DT9 DB 0DH,0AH,'$'DT0 DB 'B',0DH,0AH,'$'N EQU 5DATA ENDSCODE SEGMENTASSUME CS:CODE,DS:DATA ;说明代码段、数据段STAT: MOV AX,DATAMOV DS,AXLEA DX,DT2 ;输出字符串MOV AH,09HINT 21HCALL ZIXU ;调用数据输出过程对数据进行排序:MOV CX,N-1 ;设置N-1轮比较次数MOV DX,1 ;比较轮次技术JM4:PUSH CXMOV CX,NSUB CX,DXLEA SI,DT1JM3:MOV AX,[SI]CMP AX,[SI+2]JLE JM2XCHG AX,[SI+2]XCHG AX,[SI]JM2:ADD SI,2LOOP JM3POP CXINC DXLOOP JM4输出排序后的顺序:LEA DX,DT3MOV AH,09HINT 21HCALL ZIXU输出最大值:LEA DX,DT4MOV AH,09HINT 21HLEA SI,DT1+8 ;排序后最后一个数就就是最大值MOV AX,[SI]CALL ZIXU1输出最小值:LEA DX,DT5MOV AH,09HINT 21HLEA SI,DT1 ;排序后第一个数就就是最小值MOV AX,[SI]CALL ZIXU1输出平均值:LEA DX,DT6MOV AH,09HLEA SI,DT1+2 ;去掉最大最小后的数求与MOV AX,[SI]ADD AX,[SI+2]ADD AX,[SI+4]MOV BX,3MOV DX,0DIV BX ;求其平均值MOV CX,AXCALL ZIXU1 ;调用输出程序输出把平均值分三位输出:LEA DX,DT7MOV AH,09HINT 21HMOV AX,CXMOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,AL ;输出平均值的第一位MOV AH,2INT 21HLEA DX,DT9 ;换行MOV AH,09HINT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,AL ;输出平均值的第二位MOV AH,2INT 21HLEA DX,DT9 ;换行MOV AH,09HPOP DXADD DX,30HMOV AH,2 ;输出平均值的第三位I NT 21HLEA DX,DT9MOV AH,09HINT 21H;以二进制位输出平均值LEA DX,DT8MOV AH,09HINT 21HMOV BX,CXMOV CX,16JM5:MOV DX,0SAL BX,1RCL DX,1ADD DX,30HMOV AH,02HINT 21H DEC CXJNZ JM5LEA DX,DT0MOV AH,09HINT 21HMOV AH,4CH ;返回DOSINT 21H;数据序列的输出写成一个过程:ZIXU PROCMOV CX,5LEA SI,DT1JM1:MOV AX,[SI]MOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALINT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXADD DX,30HMOV AH,2INT 21HLEA DX,DT9MOV AH,09HINT 21HADD SI,2LOOP JM1RETZIXU ENDP;当个数据输出过程:ZIXU1 PROC ;将数据的输出写成一个过程MOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXADD DX,30HMOV AH,2INT 21HLEA DX,DT9MOV AH,09HINT 21HRETZIXU1 ENDPCODE ENDSEND STAT调试中出现的一些问题:1.输入时不慎将字母O当数字0输入,结果导致了下面第5行提示的错误。
微机原理 冒泡排序实验报告含源程序
实验报告实验名称_ _冒泡排序实验_课程名称____ __ __微机原理_____________院系部:控计学院专业班级：信安1101学生姓名：陈茹君学号:1111290106同组人:实验台号:18指导教师：闫江毓成绩：实验日期:2014年5月9日华北电力大学一、实验目的掌握用汇编语言编写气泡排序程序的思路和方法，掌握字符和数据的显示方法。
二、实验内容从键盘输入5个有符号2位十进制数，将它转换成有符号二进制数，将结果送入内存中buff开始的单元中。
将这些数从大到小排序，并将排序结果显示在屏幕上。
三、实验步骤1.算法设计1)问题分析键盘输入子程序inword 出口：buff开始的单元，CX排序子程序sort：入口：buff开始的单元，CX；出口：buff开始的单元，CX显示子程序display：入口：AL2)绘出流程图2.详细设计1)变量定义及说明.databuff db -5,-43,-32,-22,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,02)寄存器的使用及含义使用了al、ah、bl、bh、ax、bx、cx、di、si寄存器，都是用来存放数据，比较数据的大小，进行数据的值的转化和计算。
3)程序功能说明4)源程序清单.model small.data;buff db 20 dup(1)buff db -5,-43,-32,-22,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0.codestart:mov ax, @datamov ds, axcall inwordcall sortcall displaymov ax, 4c00hint 21hinword procpush axpush bxpush cxpush dxpush simov si, offset buffmov cx, 5read:mov ah, 01hint 21hmov ah, 10xor bh, bhcmp al, 2dhmov bl, 1mov ah, 01hint 21h pos:add bh, alsub bh, 30hmov ah, 01hint 21hcmp al, 20hje donesub al, 30hxchg bh, almov ah, 10mul ahadd bh, 30hjmp pos done:cmp bl, 1jne finishneg bhmov bl, 0 finish:mov [si], bhinc siloop readpop sipop dxpop cxpop bxpop axretendpsort procpush axpush cxpush sipush dimov bx, 4 first:mov al, [si]mov cx, bxmov di, si second:inc dicmp al, [di]jge nextxchg al, [di]mov [si], al next:loop secondinc sidec bxjnz firstpop dipop sipop cxpop bxpop axretendp display procpush axpush bxpush cxpush dxpush simov dl, 0dhmov ah, 02hmov dl, 0ahmov ah, 02hint 21hmov cx, 5mov si, offset buffmov dh, 10dis:test [si], 10000000bjz positivemov dl, 2dhmov ah, 02hint 21hneg [si] positive:mov al, [si]xor ah, ahdiv dhmov dl, aladd dl, 30hmov bh, ahmov ah, 02hint 21hmov dl, bhadd dl, 30hmov ah, 02hint 21hmov dl, 20hmov ah, 02hint 21hinc siloop dispop sipop dxpop cxpop axretendpend start四、调试结果及调试分析五、结论与心得我们不仅要学习书本上的知识，更要知识与实践相结合，多动手发现问题解决问题，学会举一反三、融会贯通。
汇编语言冒泡法排序
汇编语言冒泡法排序汇编语言中的冒泡排序算法如下：```assemblysection .dataarray db 5, 1, 4, 2, 8 ; 待排序的数组size equ $-array ; 数组的大小section .textglobal _start_start:mov ecx, size ; 初始化循环计数器为数组大小outer_loop:xor eax, eax ; 清零标志寄存器，用于判断是否有交换发生mov edi, 1 ; 初始化内层循环计数器为1inner_loop:movsx ebx, byte [array + edi - 1] ; 将当前元素加载到寄存器ebxcmp bl, byte [array + edi] ; 比较当前元素和下一个元素jg swap ; 如果当前元素大于下一个元素，则交换它们inc edi ; 内层循环计数器加1 loop inner_loop ; 继续内层循环cmp eax, 0 ; 判断标志寄存器是否为0jne outer_loop ; 如果有交换发生，则继续外层循环exit:mov eax, 1 ; 系统调用号1代表退出程序xor ebx, ebx ; 退出状态码为0int 0x80 ; 调用系统调用swap:mov dl, byte [array + edi] ; 将下一个元素加载到寄存器dlmov byte [array + edi], bl ; 将当前元素赋值给下一个元素mov byte [array + edi - 1], dl ; 将下一个元素赋值给当前元素mov eax, 1 ; 设置标志寄存器为非零，表示有交换发生jmp inner_loop ; 继续内层循环```这段汇编代码使用了两层循环，外层循环控制整个排序过程，内层循环用于比较相邻的两个元素并交换它们。
内层循环每次都会比较当前元素和下一个元素，如果当前元素大于下一个元素，则交换它们。
微机原理-实验一-汇编语言-冒泡排序
微机原理实验报告班级：XXXXX姓名：XXXX学号：20XXXXXXXXX大学信息科学与技术学院信息工程系实验一汇编语言程序设计-（具体题目）一、实验目的（根据实际情况修改）：1、熟悉MASM编译环境，了解程序的汇编方法；2、熟悉常用汇编指令，学习汇编程序设计方法；3、学习汇编语言的调试过程，通过调试过程认识CPU执行程序的方式；4、了解冒泡法原理，学习多重循环的编程方法。
二、实验内容：编写程序，用冒泡法实现将数据段内9,8,7,6，5,4,3,2,1按照由小到大的顺序重新排列。
三、程序流程图和程序代码1、流程图2、代码与注释（代码不能和指导书完全一样，写出注释，写出寄存器尤其是DS的值）data segmentbuf1 db 8,7,6,5,4,3,2,1data endscode segmentassume cs:code,ds:datastart: mov ax,data //传送数据段datamov ds,axmov dx,7 //dx放外循环7次L3: mov cx,dx //cx放内循环7次lea si,buf1 //将db里的数据传送到siL2: mov al,[si]cmp al,[si+1] //比较[si]与[si+1]jb L1 //[si]<[si+1],跳转到L1xchg al,[si+1] //[si]>[si+1],两两交换mov [si],alL1: inc si //si减1loop L2 //循环L2dec dx //外循环减1，没减到0则跳转到L3 jnz L3 //入内循环，计数初值mov ah,4chint 21hcode endsend start四、调试过程及遇到的问题1、程序执行截图2、调试用到的命令-U命令：查看数据段地址；-d命令：查看运行前后存储器内容；-g命令：运行程序；-t命令：查看运行前后寄存器和存储器内容。
3、遇到的问题及解决办法问题：运行程序后，数据1在存储器地址末尾没变。
四川大学微机原理冒泡法排序实验报告
《微机原理与接口技术实验报告》学院：电气信息学院班级：电力老师：学号：姓名：目录1.实验目的 (1)2.实验内容 (1)3.程序流程图 (2)4.程序清单与注释 (4)5.运行结果 (10)6.实验心得 (11)一、实验目的：经过第一次试验，我们初次了解了DEBUG调试程序强大功能。
1.学习汇编语言循环结构语句的特点，重点掌握冒泡排序的方法。
2.理解并掌握各种指令的功能，编写完整的汇编源程序。
3.进一步熟悉DEBUG的调试命令。
二、实验内容:用冒泡的方法对一组数据元素排序，它的基本方法是：将相邻的两个元素通过比较进行排序，通过多次，多遍的邻元素排序，实现整个一组数的排序。
对于5（N）个元素，整个排序通过4遍（=N-1）邻元素排序完成。
每一遍的排序由若干次邻元素的排序组成。
4遍排序中，邻元素的排序依次为4，3，2，1遍。
完成第一遍排序后，最大数沉底，已经到达它应占据的位置，不需要参加下一遍的排序。
实验要求：1.编制程序，从键盘输入300，250，280，240，260这五个数，并思考如何输入任意五个数，五个数可以有一位数，二位数，三位数，四位数，五位数，混合输入比较大小；2.对这组数用冒泡法进行排序，并输出原始数据及排序后数据，两两数据之间用空格分隔；3.利用DEBUG调试工具，用D0命令，查看排序前后，内存数据的变化，以及会用调试命令查看程序运算中寄存器中的值；4.去掉最大和最小的两个值，求出其余值的平均值，并输出最大值，最小值和平均值；5.用压栈PUSH和出栈POP指令“先进后出”的特点，设计算法将平均值按位逐个输出(即输出263)；6.用移位指令将平均值以二进制串的形式输出。
7.设计程序要有模块化的思想，用子程序实现不同的功能；8.所有数据输出前要用字符串的输出指令，进行输出提示（如：zui da zhi shi : 300等），所有数据结果能清晰地显示在电脑屏幕上。
三、程序流程图：1.主程序MAIN：2.冒泡排序子程序：SORT四、程序清单与注释：NAME BUBBLE_SORTDATA SEGMENTARRAY DW 5 DUP(?)COUNT DW 5TWO DW 2FLAG1 DW 0FLAG2 DB 0FAULT DW -1CR DB 0DH,0AH,'$'STR1 DB'Please input five numbers seperated with space and finished with Enter:','$'STR2 DB'The original numbers:','$'STR3 DB'The sorted numbers:','$'STR4 DB'The Min:','$'STR5 DB'The Max:','$'STR6 DB'The Average:','$'STR7 DB'The binary system of the average:','$'STR8 DB'Input error!Please input again!','$'DATA ENDSCODE SEGMENTMAIN PROC FARASSUME CS:CODE,DS:DATA,ES:DATASTART: PUSH DSAND AX,0PUSH AXMOV AX,DATAMOV DS,AXLEA DX,STR1MOV AH,09HINT 21HCALL CRLFREIN: CALL INPUTCMP AX,FAULTJE REINLEA DX,STR2MOV AH,09HINT 21HCALL OUTPUTCALL SORTLEA DX,STR3MOV AH,09HINT 21HCALL OUTPUTAND SI,0AND BX,0MOV BX,ARRAY[SI] LEA DX,STR4MOV AH,09HINT 21HCALL ONECALL CRLFLEA DX,STR5MOV AH,09HINT 21HMOV BX,ARRAY[SI+8] CALL ONECALL CRLFLEA DX,STR6MOV AH,09HINT 21HAND DX,0MOV AX,ARRAY[SI+2] ADD AX,ARRAY[SI+4] ADC AX,ARRAY[SI+6] MOV CX,COUNTDEC CXDEC CXDIV CXMOV BX,AXCALL ONECALL CRLFLEA DX,STR6MOV AH,09HMOV CX,16LL1: AND DX,0DIV TWOPUSH DXLOOP LL1MOV CX,16LL2: POP DXADD DL,30HMOV AH,2INT 21HLOOP LL2MOV AH,4CHINT 21HMAIN ENDPCRLF PROCLEA DX,CRMOV AH,09HINT 21HRETCRLF ENDPINPUT PROCMOV CX,COUNTAND SI,0NEXT1: CALL DTBDEC CXCMP DL,20HJE STOCMP DL,0DHJE EXIT2CALL CRLF ERROR: LEA DX,STR8 MOV AH,09HINT 21HCALL CRLFMOV AX,FAULTJMP EXIT3STO: MOV ARRAY[SI],BX ADD SI,2JMP NEXT1EXIT2: MOV ARRAY[SI],BX CALL CRLFEXIT3: RETINPUT ENDPDTB PROCAND BX,0AND FLAG1,0 CHAR: MOV AH,01HINT 21HMOV DL,ALCMP AL,2DHJNZ NEXT2MOV FLAG1,1JMP CHARNEXT2: SUB AL,30HJL NEXT3CMP AL,09HJG NEXT3CBWXCHG AX,BXMOV CX,10MUL CXXCHG AX,BXADD BX,AXJMP CHARNEXT3: CMP FLAG1,1JNZ EXIT1NEG BXEXIT1: RETDTB ENDPOUTPUT PROCCALL CRLFMOV DI,COUNTAND SI,0GO1: MOV BX,ARRAY[SI] TEST BX,8000HJZ GO2MOV DL,2DHMOV AH,02HINT 21HNEG BXGO2: CALL ONEMOV DL,2DHMOV AH,02HINT 21HADD SI,2DEC DIJNZ GO1CALL CRLFRETOUTPUT ENDPONE PROCPUSH BXPUSH CXPUSH SIPUSH DIMOV CX,10000 CALL BTDMOV CX,1000 CALL BTDMOV CX,100 CALL BTDMOV CX,10CALL BTDMOV CX,1CALL BTDADD DL,FLAG2 CMP DL,30H JNE QUIT3MOV AH,02H INT 21H QUIT3: POP DIPOP SIPOP CXPOP BXAND FLAG2,0 RETONE ENDPBTD PROCMOV AX,BXAND DX,0DIV CXMOV BX,DXMOV DL,ALADD DL,30H CMP FLAG2,0 JNE QUIT1CMP DL,30HJE QUIT2MOV FLAG2,1QUIT1: MOV AH,02HINT 21HQUIT2: RETBTD ENDPSORT PROCCLDMOV CX,COUNTDEC CXLOO1: MOV DI,CXAND SI,0LOO2: MOV AX,ARRAY[SI] CMP AX,ARRAY[SI+2] JL LOO3XCHG AX,ARRAY[SI+2] MOV ARRAY[SI],AX LOO3: ADD SI,2LOOP LOO2MOV CX,DILOOP LOO1RETSORT ENDPCODE ENDSEND START五、运行结果：1.对300、250、280、240、260五个数据进行冒泡排序，运行结果如下：2、对5802、129、30、7、1233五个数据进行冒泡排序，运行结果如下：3.对-1、23、189、-234、6五个数据进行冒泡排序，运行结果如下：4.当输入不合法时，显示如下：六、实验心得：在本次汇编语言程序设计实验中，我们运用了循环结构对冒泡排序进行了汇编设计。
计算机组成原理实验-基于x86汇编指令实现冒泡排序
PB12011047施连杰本程序设计中，假设最终将给出的待排序列NUM[1…n]按从小到大有序排列。
此时冒泡排序的原理为，每趟比较从第一个元素开始，将相邻两元素NUM[i]与NUM[i+1]比较，若NUM[i]大于NUM[i+1]，则交换两元素，于是每趟比较总能将本次序列中最大的元素NUM[i m]交换到末尾。
再进行下一轮比较，由于最大元素已经沉底，不必再参与比较，因此序列的末尾前移一项，此时又可将剩余元素中的最大元素沉底。
不断重复单趟排序，直到序列的头尾相重合，则冒泡结束，得到了有序序列。
根据冒泡排序的原理，可以得到程序的基本设计思路，即采用两重循环来实现。
第一重循环控制每趟排序，第二重循环则控制单趟排序中的每次比较。
用DI存放控制第一重循环的计数值，初始化为COUNT-1，COUNT是数组中的元素个数；每一轮循环结束，递减DI值并利用JNZ条件跳转语句判断循环是否继续。
BX用于存放数组元素序号，每一轮第一重循环开始时BX初始化为0；由于数据采用DW格式，故[BX]每次递增的值应为2。
第二重循环中，每次比较时将NUM[BX]的值移入寄存器AX中，并与NUM[BX+2]的值进行比较，利用JLE条件跳转指令，若NUM[BX]>NUM[BX+2]，则交换两者的值。
此外，寄存器DX用以存放每趟排序的终点，初始化为2*(COUNT-1)；每趟排序完成后，由于最大元素已经沉底，不必再参与下一趟排序，因此将DX的值递减2。
每一次比较结束之后，更新BX的值，并比较[BX]+2与[DX]的值，以判断此趟排序是否到终点。
关于X86的汇编指令和硬件规定，直接参考相关资料。
汇编程序如下DATA SEGMENTNUM DW 11,4,2,15,7,9,13,5,12,6,8,1 ;待排序数据COUNT EQU ($-NUM)/2 ;数据个数DATA ENDSMAIN SEGMENTASSUME C S:MAIN,DS:DATABEGIN: MOV AX,DATAMOV DS,AXMOV DI,COUNT-1 ;判断LOOP1是否进行MOV DX,COUNT-1ADD DX,DX ;表示每趟冒泡的终点LOOP1: MOV CX,DI ;LOOP1循环计数MOV BX,0 ;数据数组元素序号JMP LOOP2SETBX: SUB BX,2 ;修改BX为正确的起始值LOOP2: MOV AX,NUM[BX]CMP AX,NUM[BX+2] ;比较NUM[BX],NUM[BX+2]JLE NEXT ;可用于有符号数XCHG AX,NUM[BX+2] ;若大于,则交换相邻两数MOV NUM[BX],AXNEXT: ADD BX,4 ;BX为下一次比较起点CMP BX,DX ;将BX+2与DX进行比较JLE SETBXSUB DX,2 ;最大数已经沉底,下一趟不比较DEC DIJNZ LOOP1 ;判断循环是否继续MOV AX,4C00HINT 21HMAIN ENDSEND B EGIN使用DOSBox进行Debug，首先进行相关配置。
用汇编语言冒泡排序经典程序
冒泡排序时间复杂度
最好情况：O(n)
平均情况：O(n²)
最坏情况：O(n²)
Part Two
汇编语言基础知识
汇编语言概述
汇编语言是一种低级编程语言，与机器语言相对应。
它使用助记符和操作码表示指令，易于理解和编写。
汇编语言通常用于嵌入式系统、操作系统等底层开发。
注意事项：确保编译和链接的正确性，避免出现错误和警告
工具使用：使用编译器和链接器等工具进行编译和链接
链接过程：将目标文件合并成一个可执行文件
程序运行及结果
输入数据：随机生成一组整数
程序运行过程：按照冒泡排序算法进行排序
输出结果：排序后的整数序列
测试结果：对多个不同规模的输入数据进行测试，验证程序的正确性和稳定性
代码注释：对每行代码进行详细解释，帮助理解算法实现过程
代码解析：分析代码结构，解释冒泡排序算法的汇编语言实现方式
寄存器使用：说明在汇编语言中如何使用寄存器进行数据交换和比较
优化点：分析代码中可以优化的地方，提高程序执行效率
Part Four
程序运行及测试
程序编译链接
编译过程：将源代码转换成机器语言
指令格式：汇编语言指令由操作码和操作数组成，操作码指明指令的操作类型，操作数指明操作数或操作数的地址。
伪指令：伪指令不是真正的计算机指令，而是用于告诉汇编程序如何组织程序的一种指示。常见的伪指令包括ORG、END、DB、DW等。
Part Three
汇编语言实现冒泡排序
排序数据准备
确定排序数据类型：根据具体需求选择合适的数据类型，如整数、字符等。
优化效果：通过减少数据交换次数，可以提高冒泡排序算法的执行效率，减少程序运行时间
微机原理实验报告
微机原理实验报告——冒泡法实现数据排序姓名：XXX学号：1043031467专业：电气工程及其自动化一、实验内容用“冒泡“法对一组数300，250，280，240，260，按从小到大的顺序排列。
提示：用冒泡的方法对一组数据元素排序，它的基本方法是：将相邻的两个元素通过比较进行排序，通过多次，多遍的邻元素排序，实现整个一组数的排序。
对于5（N）个元素，整个排序通过4遍（=N-1）邻元素排序完成。
每一遍的排序由若干次邻元素的排序组成。
4遍排序中，邻元素的排序依次为4，3，2，1遍。
完成第一遍排序后，最大数沉底，已经到达它应占据的位置，不需要参加下一遍的排序。
外循环的次数为CX=4次(N-1)，内循环的次数为4，3，2，1(DEC CX)排序遍数本遍排序前第一次排序后第二次排序后第三次排序后第四次排序后1 300，250，280，240，260 250，300，280，240，260250，280，300，240，260250，280，240，300，260250，280，240，260，3002 250，280，240，260，300250，280，240，260，300250，240，280，260，300250，240，260，280，3003 250，240，260，280，300250，240，260，280，300240，250，260，280，3004 240，250，260，280，300240，250，260，280，300实验要求：1.编制程序，对这组数进行排序，并输出原数据及排序后数据；2.利用DEBUG调试工具，用D0命令，查看排序前后，内存数据的变化；3. 去掉最大和最小的两个值，求出其余值的平均值，并输出最大值，最小值和平均值；4. 用学过的压栈PUSH和出栈POP指令，将平均值按位逐个输出(即输出263)；5将平均值263转化为二进制串，并将这组二进制串输出。
6.所有数据输出前要用字符串的输出指令，进行输出提示（如：zui da zhi shi : 300等），所有数据结果能清晰地显示在屏幕上。
微机上机实验冒泡排序法
微机上机实验冒泡排序法DATAS SEGMENTINPUT DB 'INPUT',10,13,'$'NUM1 DB 4,?,3 DUP(?)NUM2 DB 4,?,3 DUP(?)NUM3 DB 4,?,3 DUP(?)NUM4 DB 4,?,3 DUP(?)NUM5 DB 4,?,3 DUP(?)NUM DB 3 DUP (?);作为比较后交换的一个过渡AV DB ?,?,?PAIXU DB 'PAI XU HOU DE SHU ZHI',10,13,'$'MAX DB 'ZUI DA ZHI SHI',10,13,'$'MIN DB 'ZUI XIAO ZHI SHI',10,13,'$'AVERAGE DB 'PING JUN SHU SHI',10,13,'$'TIME DW ?;过渡值TIME1 DB ?;过渡值CHUSHU1 DW 3CHUSHU DB 100,10HESHU DW ?STRINGS1 DB 16 DUP(?)STRINGS2 DB 'ER JIN ZHI CHUAN',10,13,'$'DATAS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATASSTART:MOV AX,DATASMOV DS,AXMOV ES,AXLEA DX,INPUT;显示INPUTMOV AH,9INT 21H;*************************************************输入5个待比较数字MOV CX,5;输入五个数字MOV SI,0AGAIN:LEA DX,[NUM1+SI];输入字符串MOV AH,10INT 21HMOV DL,10;输入后换行MOV AH,2ADD SI,5;指针加5，指向下一个变量LOOP AGAIN;*************************************************比较五个数的大小，并从小到大排序CLDMOV CX,4L1: MOV BP,0PUSH CX;计数器入栈BJ:MOV AX,CXMOV CX,3LEA SI,[NUM1+BP+2];逐位比较两个数大小LEA DI,[NUM1+BP+7]REPZ CMPSBJB L2;如果小于直接比较下一个数，否则两个数对换位置MOV CX,3LEA SI,NUM1[BP+2];LEA DI,NUMREP MOVSBMOV CX,3LEA SI,NUM1[BP+7]LEA DI,NUM1[BP+2]REP MOVSBMOV CX,3LEA SI,NUMLEA DI,NUM1[BP+7]REP MOVSBL2:ADD BP,5;BP加5，执行后指向后面两个数字MOV CX,AXLOOP BJ;CX不等于零继续比较POP CX;计数器出栈LOOP L1;*************************************************输出排序后的5个数字LEA DX,PAIXU;输出字符串'PAI XU HOU DE SHU ZHI'MOV AH,9INT 21HMOV CX,5MOV SI,2OUTPUT:PUSH CX;计数器入栈MOV CX,3L3:MOV AL,[NUM1+SI];输出数字MOV AH,2INT 21HINC SILOOP L3MOV DL,3CHMOV AH,2INT 21HADD SI,2POP CX;计数器出栈LOOP OUTPUTMOV DL,10MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21H;*************************************************求除最大最小数之外三个数的平均数MOV CX,3MOV BX,10;除数10MOV SI,2ADD0:MOV DX,0MOV AH,0MOV TIME,CX;将CX暂时放在TIME中MOV CX,3ADD1:MOV AL,[NUM2+SI];将十进制数转换为二进制数SUB AL,30HPUSH AXMOV AX,DXMUL BXMOV DX,AXPOP AXADD DX,AXINC SILOOP ADD1;每执行完一次，就完成一个3位十进制数的转换ADD SI,2MOV CX,TIMEADD HESHU,DX;将DX的数放在HESHU中LOOP ADD0;CX=0时，就完成三个十进制数转换为二进制数之后的相加和MOV DX,HESHU;MOV AX,DXXOR DX,DXDIV CHUSHU1;除3取平均值,CHUSHU1是字变量，结果将商放在AX中，余数放在DX中;*************************************************将平均数转化为相应的字符MOV BX,AX;给BX赋值平均数DIV CHUSHU;除100取最高位ADD AL,30H;转换为ASCII码MOV AV,ALMOV AL,AHXOR AH,AHDIV [CHUSHU+1];除10取十位ADD AL,30HADD AH,30H;余数就是个位MOV [AV+1],ALMOV [AV+2],AH;*************************************************输出最大数，最小数，平均数LEA DX,MAX;输出字符串'ZUI DA ZHI SHI'MOV AH,9INT 21HMOV CX,3MOV SI,2L4: MOV DL,[NUM5+SI];输出最大字MOV AH,2INT 21HINC SILOOP L4MOV DL,10;输出最大字后换行MOV AH,2INT 21HLEA DX,MIN;输出字符串'ZUI XIAO ZHI SHI'MOV AH,9INT 21HMOV CX,3MOV SI,2L5: MOV DL,[NUM1+SI];输出最小字MOV AH,2INT 21HINC SILOOP L5MOV DL,10;输出最小字后换行MOV AH,2INT 21HLEA DX,AVERAGE;输出字符串'PING JUN SHU SHI'MOV AH,9INT 21HMOV CX,3MOV SI,0L6: MOV DL,[AV+SI];输出平均数MOV AH,2INT 21HINC SILOOP L6MOV DL,10;输出最平均数后换行MOV AH,2INT 21H;*************************************************将平均数转换为二进制串，并输出LEA DX,STRINGS2 ;输出字符串'ER JIN ZHI SHU'MOV AH,9INT 21HL7: MOV CX,LENGTH STRINGS1;将平均数转换成二进制串，放在STRINGS1中LEA DI,STRINGS1PUSH CXMOV AL,30H;将STEINGS1中字符全部写为'0'REP STOSBPOP CXMOV SI,0L8: RCL BX,1JNC L9MOV [STRINGS1+SI],31HL9: MOV DL,[STRINGS1+SI];将二进制串逐个输出MOV AH,2INT 21HINC SILOOP L8MOV AH,4CHINT 21HCODES ENDSEND START。
汇编语言实现冒泡排序(一)
;用汇编语言实现实现冒泡排序，并将排序后的数输出DATAS SEGMENTA dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45N=$-A ;计算数字所占的字节数DATAS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATASSTART:MOV AX,DATASMOV DS,AXMOV SI,0 ;SI遍历数字;前一个数的地址MOV CX,N/2-1 ;设置循环次数，M(M=N/2)个数需要，循环M-1次 CALL BUBBLE ;调用BUBBLE将原来的数排序;输出排序后的数MOV CX,N/2 ;循环M次输出排序后的M个数MOV SI,0 ;SI遍历排序后的数MOV DI,0 ;用DI记录数字的位数MOV BP,N+5 ;BP用于遍历存储的转化后的字符的位置SHOW: PUSH CX ;循环次数入栈MOV DX,0 ;由于将要进行16位除需要置高16位为0MOV AX,[SI] ;低16位为排序后的数CALL DTOC ;调用DTOC将十进制数转换为字符串CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出ADD SI,2 ;下一个数POP CX ;循环次数出栈栈LOOP SHOWMOV AH,4CHINT 21H;冒泡排序BUBBLE PROCL1: PUSH CX ;将循环次数入栈LEA SI,A ;SI遍历DATAS数据段的数字L2: MOV AX,A[SI] ;将前一个数存于AXCMP AX,A[SI+2] ;比较前后两个数JBE NEXT ;如果前一个数小于或等于后一个数则继续本轮的比较XCHG AX,A[SI+2] ;否则，交换前后两个数的位置MOV A[SI],AXNEXT:ADD SI,2 ;下一个数LOOP L2 ;注意内层循环的次数已经确定了POP CX ;将循环次数出栈LOOP L1 ;下一轮比较RETBUBBLE ENDP;将十进制数转换为字符串并储存起来DTOC PROCS:MOV CX,10 ;将除数10，放入CX中CALL DIVDW ;调用DIVDW程序ADD CL,30H ;把数字转换为ASCII码，这样就能显示了MOV DS:[BP],CL ;把ASCII码放到内存中INC DI ;用DI记录循环的次数PUSH AX ;将低16位入栈ADD AX,DX ;将高位与低位相加，接着判断是否已经除尽JZ BACK ;除尽后返回调用处POP AX ;将低16位出栈DEC BP ;逆序存放转化后的字符，便于主程序调用SHOW_STR JMP SBACK:POP AX ;为了得到正确的IP值，需要出栈一次RETDTOC ENDP;子程序定义开始,功能是分离被除数的各个位的数字;公式：X/N=int(H/N)*65536+[rem(H/N)*65536+L]/NDIVDW PROCPUSH AX ;低16位入栈MOV AX,DX ;将高16位写入AX,MOV DX,0 ;将高16位置零DIV CX ;将新的数除10,MOV BX,AX ;将商int(H/N)转移到BX，默认余数rem(H/N)在DX POP AX ;将低16位出栈，DIV CX ;将[rem(H/N)*65536+L]除10,默认余数在DXMOV CX,DX ;将余数转移到CXMOV DX,BX ;将商int(H/N)转移到dx,相当于int(H/N)*65536RET ;子程序定义结束DIVDW ENDP;实现字符串的输出SHOW_STR PROCS2:MOV AH,2 ;输出数字转化后的字符串MOV DL,DS:[BP]INT 21HINC BP ;顺序输出DEC DI ;数字的位数减一JZ OK ;字符串输出完了就结束JMP S2 ;否则继续输出OK:MOV AH,2 ;输出空格MOV DL,0INT 21HRETSHOW_STR ENDPCODES ENDSEND START;实现冒泡排序，并将排序后的数输出DATAS SEGMENTA dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45N=$-A ;计算数字所占的字节数DATAS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATASSTART:MOV AX,DATASMOV DS,AXMOV SI,0 ;SI遍历数字;前一个数的地址MOV CX,N/2-1 ;设置循环次数，M(M=N/2)个数需要，循环M-1次 CALL BUBBLE ;调用BUBBLE将原来的数排序;输出排序后的数MOV CX,N/2 ;循环M次输出排序后的M个数MOV SI,0 ;SI遍历排序后的数MOV DI,0 ;用DI记录数字的位数MOV BP,N+5 ;用于遍历存储的转化后的字符的位置SHOW: PUSH CX ;循环次数入栈MOV DX,0 ;由于将要进行16位除需要置高16位为0MOV AX,[SI] ;低16位为排序后的数CALL DTOC ;调用DTOC将十进制数转换为字符串CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出ADD SI,2 ;下一个数POP CX ;循环次数出栈栈LOOP SHOWMOV AH,4CHINT 21HBUBBLE PROCL1: PUSH CX ;将循环次数入栈LEA SI,A ;SI遍历DATAS数据段的数字L2: MOV AX,A[SI] ;将前一个数存于AXCMP AX,A[SI+2] ;比较前后两个数JBE NEXT ;如果前一个数小于或等于后一个数则继续本轮的比较XCHG AX,A[SI+2] ;否则，交换前后两个数的位置MOV A[SI],AXNEXT:ADD SI,2 ;下一个数LOOP L2 ;注意内层循环的次数已经确定了POP CX ;将循环次数出栈LOOP L1 ;下一轮比较RETBUBBLE ENDP;将十进制数转换为字符串并储存起来DTOC PROCS:MOV CX,10 ;将除数10，放入CX中CALL DIVDW ;调用DIVDW程序ADD CL,30H ;把数字转换为ASCII码，这样就能显示了MOV DS:[BP],CL ;把ASCII码放到内存中INC DI ;用DI记录循环的次数PUSH AX ;将低16位入栈ADD AX,DX ;将高位与低位相加，接着判断是否已经除尽JZ BACK ;除尽后返回调用处POP AX ;将低16位出栈DEC BP ;逆序存放转化后的字符，便于主程序调用SHOW_STR JMP SBACK:POP AX ;为了得到正确的IP值，需要出栈一次RETDTOC ENDP;子程序定义开始,功能是分离被除数的各个位的数字;公式：X/N=int(H/N)*65536+[rem(H/N)*65536+L]/NDIVDW PROCPUSH AX ;低16位入栈MOV AX,DX ;将高16位写入AX,MOV DX,0 ;将高16位置零DIV CX ;将新的数除10,MOV BX,AX ;将商int(H/N)转移到BX，默认余数rem(H/N)在DX POP AX ;将低16位出栈，DIV CX ;将[rem(H/N)*65536+L]除10,默认余数在DXMOV CX,DX ;将余数转移到CXMOV DX,BX ;将商int(H/N)转移到dx,相当于int(H/N)*65536 RET ;子程序定义结束DIVDW ENDP;实现字符串的输出SHOW_STR PROCS2:MOV AH,2 ;输出数字转化后的字符串MOV DL,DS:[BP]INT 21HINC BP ;顺序输出DEC DI ;数字的位数减一JZ OK ;字符串输出完了就结束JMP S2 ;否则继续输出OK:MOV AH,2 ;输出空格MOV DL,0INT 21HRETSHOW_STR ENDPCODES ENDSEND START。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
微机原理实验报告
班级：XXXXX
姓名：XXXX
学号：20XXXX
XXXXX大学
信息科学与技术学院
信息工程系
实验一汇编语言程序设计-（具体题目）
一、实验目的（根据实际情况修改）：
1、熟悉MASM编译环境，了解程序的汇编方法；
2、熟悉常用汇编指令，学习汇编程序设计方法；
3、学习汇编语言的调试过程，通过调试过程认识CPU执行程序的方式；
4、了解冒泡法原理，学习多重循环的编程方法。
二、实验内容：
编写程序，用冒泡法实现将数据段内9,8,7,6，5,4,3,2,1按照由小到大的顺序重新排列。
三、程序流程图和程序代码
1、流程图
2、代码与注释（代码不能和指导书完全一样，写出注释，写出寄存器尤其是DS的值）
data segment
buf1 db 8,7,6,5,4,3,2,1
data ends
code segment
assume cs:code,ds:data
start: mov ax,data //传送数据段data
mov ds,ax
mov dx,7 //dx放外循环7次
L3: mov cx,dx //cx放内循环7次
lea si,buf1 //将db里的数据传送到si
L2: mov al,[si]
cmp al,[si+1] //比较[si]与[si+1]
jb L1 //[si]<[si+1],跳转到L1
xchg al,[si+1] //[si]>[si+1],两两交换
mov [si],al
L1: inc si //si减1
loop L2 //循环L2
dec dx //外循环减1，没减到0则跳转到L3 jnz L3 //入内循环，计数初值
mov ah,4ch
int 21h
code ends
end start
四、调试过程及遇到的问题
1、程序执行截图
2、调试用到的命令
-U命令：查看数据段地址；
-d命令：查看运行前后存储器内容；
-g命令：运行程序；
-t命令：查看运行前后寄存器和存储器内容。
3、遇到的问题及解决办法
问题：运行程序后，数据1在存储器地址末尾没变。
解决方法：暂未解决！
五、思考题
1、n个数冒泡法排序共需要多少次循环？
答：n(n-1)/2次。
2、循环嵌套时总循环次数和内外循环次数是哪种数学关系？编写内外循环嵌套的双重循环程序，实现100次内循环，300次外循环。
答：总循环次数=内循环次数*外循环次数；
六、心得体会
通过实际模拟操作，加深了对CPU的理解，更好的理解编程语言，本次实验较为简单，我独立按时完成。
在试验的编程过程中，弄清了DOSBox的使用方法，以及冒泡法排序的计算。
实验过程遇到了程序调试和代码不熟的问题，在同学帮助下，弄懂了每行代码的作用，经调试，发现挺简单的。
因此，我了解了在程序执行过程中，DS寄存器的值是根据实际数据段的地址分配的，并且不能和代码段重复。