ARM汇编 冒泡排序 实验报告
冒泡排序(实验报告)
一、实验目的和要求理解和掌握冒泡排序技术，使用C语言根据相应算法编写一个程序，实现冒泡排序。
要求仔细阅读下面的内容，编写C程序，上机通过，并观察其结果，写出实验报告书。
二、实验内容和原理内容：用冒泡排序对顺序存储的长度为10的无序线性表排序。
原理：首先，从表头开始往后扫描线性表，依次比较相邻两个元素，若前面的元素大于后面的元素，将它们交换。
然后，从后往前扫描后面的线性表，依次比较相邻两个元素，若后面的元素大于前面的元素，将它们交换。
对剩下的线性表重复上述过程，直到剩余表为空。
此时的线性表为有序。
三、主要仪器设备计算机一台四、实验主程序#include<stdio.h>void bub(int a[],int n);int main(void){inta[10]={456,1564,1231,44,1,32,78,15,3,6 56},i;for(i=0;i<10;++i)printf("%d ",a[i]);printf("\n");bub(a,10);for(i=0;i<10;++i)printf("%d ",a[i]);printf("\n");getchar();return 0;}void bub(int a[],int n){int i,j,k,m,temp;k=0;m=n-1;while(k<m){j=m;m=0;for(i=k;i<j;++i)if(a[i]>a[i+1]){temp=a[i];a[i]=a[i+1];a[i+1]=temp;m=i;}j=k;k=0;for(i=m;i>j;--i)if(a[i]<a[i-1]){temp=a[i];a[i]=a[i-1];a[i-1]=temp;k=i;}}}实验结果五、实验心得通过实验学习，我理解了冒泡排序的算法，并实现了用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写程序时，直接可以用%开头的格式命令进行特定类型的数据输入输出，但是用汇编时就没有那么好办了，输入的时候要识别数据，输出也要转化数据。
(中断、冒泡排序、1602)单片机实验报告
本科生实验报告实验课程单片机实验学院名称信息科学与技术学院专业名称物联网工程学生姓名曹林鑫学生学号201413060301指导教师谢兴红实验地点6B607实验成绩二〇一六年九月二〇一六年十二月实验一冒泡排序（汇编）一．实验目的掌握单片机的汇编语言排序程序。
二．实验内容将单片机内部的数据进行排序，且使用汇编语言。
三．实验要求根据实验内容编写一个程序，数据排列顺序要求是从小到大。
四．实验说明先在片内RAM中存储一组数据，重复地走访过要排序的数据，一次比较两块内存上的数据，如果他们的顺序错误就把他们交换过来。
走访数据的工作是重复地进行直到没有再需要交换，也就是说该列数据已经排序完成。
五．算法分析若文件的初始状态是正序的，一趟扫描即可完成排序。
所需的关键字比较次数C和记录移动次数M均达到最小值：，。
所以，冒泡排序最好的时间复杂度为O（n）。
若初始文件是反序的，需要进行n-1 趟排序。
每趟排序要进行n-i次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。
在这种情况下，比较和移动次数均达到最大值：冒泡排序的最坏时间复杂度为。
综上，因此冒泡排序总的平均时间复杂度为。
六．实验程序及分析ORG 0000HLJMP mainORG 0100Hmain:MOV 40H,#05H//在40H-44H中随机存放五个立即数MOV 41H,#08HMOV 42H,#09HMOV 43H,#07HMOV 44H,#06HMOV R7,#04H//控制比较循环的次数MOV R6,#04HLOOP3:MOV R0,#40H//指向需要进行比较的数据的地址MOV R1,#41H//MOV A,R6MOV R7,ACLR ALOOP1:CLR CMOV A,@R1MOV 49H,A //交换数据前的备份SUBB A,@R0//用进位标志判断两数的大小JC LOOPLJMP LOOP4LOOP:MOV A, @R0//恢复交换前的备份数据MOV @R1,AMOV @R0,49HLOOP4:INC R0INC R1DJNZ R7,LOOP1//控制比较的次数DJNZ R6,LOOP3//控制比较的轮数LJMP $END六、实验截图排序前内存中的数据排序后内存的数据实验二外部中断一．实验目的1、掌握单片机外部中断的原理及过程。
冒泡排序实验报告心得(3篇)
第1篇一、实验背景在本次数据结构与算法课程中，我们学习了多种排序算法，其中冒泡排序作为最基础的排序算法之一，引起了我的浓厚兴趣。
通过本次实验，我对冒泡排序的原理、实现过程以及优化方法有了更深入的理解。
二、实验目的1. 理解冒泡排序算法的原理和基本思路。
2. 掌握冒泡排序的代码实现。
3. 分析冒泡排序的优化方法，提高算法效率。
4. 通过实验加深对排序算法的理解，为以后学习更复杂的排序算法打下基础。
三、实验过程1. 原理学习：首先，我详细学习了冒泡排序的原理。
冒泡排序是一种简单的交换排序算法，通过相邻元素的比较和交换，逐步将数组排序。
基本思路是：比较相邻的两个元素，如果它们的顺序错误（如第一个比第二个大），就交换它们的位置；然后，再对下一对相邻元素进行比较和交换，如此反复，直到没有需要交换的元素，数组就完成了排序。
2. 代码实现：接下来，我动手编写了冒泡排序的代码。
在编写过程中，我注意了以下几点：- 使用双层循环实现冒泡排序，外层循环控制排序的轮数，内层循环控制每一轮中相邻元素的比较和交换。
- 使用一个标志变量记录每一轮是否有元素交换，如果没有交换，则表示数组已经排序完成，可以提前结束排序。
3. 优化方法：为了提高冒泡排序的效率，我尝试了以下优化方法：- 在每一轮排序中，记录最后一次交换的位置，这个位置之后的元素已经是有序的，下一轮排序可以忽略。
- 如果在某一轮排序中没有发生任何交换，则可以认为数组已经排序完成，可以提前结束排序。
4. 实验测试：在编写代码后，我对冒泡排序进行了测试，测试数据包括已排序数组、部分排序数组以及逆序数组。
实验结果表明，冒泡排序可以正确地对这些数据进行排序。
四、实验心得1. 原理理解：通过本次实验，我对冒泡排序的原理有了更加深入的理解。
冒泡排序虽然是一种简单的排序算法，但其思想在许多其他排序算法中都有体现，如快速排序、堆排序等。
2. 代码实现：在编写代码的过程中，我学会了如何将算法原理转化为代码，并注意了代码的可读性和可维护性。
冒泡法排序实验报告
冒泡法排序实验报告一、实验任务实现N个16位无符号整数的排序，核心程序使用汇编语言实现。
二、程序算法冒泡法：若有n个数需要排序，则第一次遍历n个数，将x[0]与x[1]相比，若x[0]>x[1],则两数交换位置，若x[0]<x[1],则不作任何调整；然后将x[0]与x[2]相比较，若x[0]>x[2],则两数交换位置；若x[0]<x[2],则不作任何调整；依此类推，直到x[0]与x[n]比较完毕为止。
接着第二次遍历n-1个数，将x[1]与x[2]相比，若x[1]>x[2],则两数交换位置，若x[0]<x[1],则不作任何调整；一直到x[1]与x[n]比较完毕为止。
最后一直到只需要遍历2个数，比较调整完毕就可以得到数组从小到大的排列次序，算法在每次遍历时使最小的数象气泡一样冒到顶端，在经历n-1次遍历以后即可得到结果。
三、源程序及注释//冒泡排序法#include <iostream.h>int main(int argc, char* argv[]){unsigned short int x[33]; //排序个数上限为33个unsigned short int i,j,n;unsigned short int a,b;//提示输入排序个数cout<<"Please input the count of numbers: \n";cin>>n;//提示输入需要排序的各个数cout<<"Please input the numbers: \n";x[0] = 0;for(i=1;i<n+1;i++) //初始化需要排序的数组x[n]cin>>x[i];for(i=0;i<=n;i++) //冒泡法排序{for(j=n;j>=i+1;j--) //每次遍历n-i个数{a = x[j-1];b = x[j];_asm{mov ax,a //将一个数读入到axcmp ax,b //比较两数大小jc exit //若a小则跳出xchg ax,b //若b小则两数交换次序mov a,axexit: NOP}x[j-1] = a; //保存两数排序结果x[j] = b;}}//输出排序结果，按从小到大排列cout<<"The Result is : \n";for(i=1;i<n+1;i++)cout<<x[i]<<' ';cout<<'\n';return 0;}四、实验结果。
ARMC语言调用汇编函数实现冒泡排序
ARMC语⾔调⽤汇编函数实现冒泡排序使⽤冒泡排序将指定数组排序后输出排序函数使⽤汇编语⾔编写，C语⾔调⽤汇编语⾔在控制台显⽰排序前后的结果⼀、问题分析本程序的关键是如何使⽤汇编语⾔实现冒泡排序算法。
可以仿照C语⾔的代码流程，分步骤写出汇编的代码。
⾸先要写出最内层的代码部分，也就是数据交换的汇编代码，数据交换可以使⽤str数据装载指令实现。
之后要考虑内层循环的代码，可以通过cmp指令控制循环次数。
最后是编写最外层的循环代码，也是使⽤cmp指令，来控制整个排序的次数。
⼆、代码编写2.1 C语⾔代码#include <stdio.h>extern void sort(char* num, int count);int main(){char number[10] = {'a', 'c', 'b', 'e', 'd', 'f', 'h', 'g', 'j', 'i'};printf("Before: %s\n", number);sort(number, 10);printf("After: %s\n", number);return 0;}C语⾔中⽐较重要的是，⾸先要声明外部函数sort，也就是由汇编代码实现的函数。
其代码流程为：初始化1个10字节的char类型的数组在控制台输出初始化的数据调⽤汇编函数进⾏排序显⽰排序后的结果2.2 汇编代码area sort, code, readonlyglobal sortstartmov r2, #-1 ; r2->i, i=-1sub r8, r1, #1 ; r1->countloopcmp r2, r8 ; 控制外层循环bge stopadd r2,r2, #1 ; i=i+1mov r3, #-1 ; r3=j, j=-1loop0add r3, r3, #1 ; j=j+1add r4, r3, #1 ; r4=j+1sub r7, r8, r2 ; 控制内层循环cmp r3, r7bge loopldrb r5, [r0, r3] ; r5=a[j]ldrb r6, [r0, r4] ; r6=a[j+1]cmp r5, r6 ; ⽐较 a[j] 和 a[j+1]blt loop0swapstrb r5, [r0, r4] ; 交换 a[j] 和 a[j+1]strb r6, [r0, r3]b loop0stopend汇编语⾔代码是仿照的C语⾔的冒泡排序流程实现的，其⼤致流程为：⾸先初始化R2，R2⽤来控制外层循环的次数。
微机原理实验报告-冒泡排序
一、实验目的（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. 实验步骤（1）设计一个冒泡排序函数，输入为待排序的数组，输出为排序后的数组。
（2）编写一个主函数，用于测试冒泡排序函数的正确性和性能。
（3）通过不同的数据规模和初始顺序，分析冒泡排序的性能特点。
3. 实验环境（1）编程语言：C语言（2）开发环境：Visual Studio Code（3）测试数据：随机生成的数组、有序数组、逆序数组三、实验过程1. 冒泡排序函数设计```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```2. 主函数设计```cinclude <stdio.h>include <stdlib.h>include <time.h>int main() {int n;printf("请输入数组长度：");scanf("%d", &n);int arr = (int )malloc(n sizeof(int)); if (arr == NULL) {printf("内存分配失败\n");return 1;}// 生成随机数组srand((unsigned)time(NULL));for (int i = 0; i < n; i++) {arr[i] = rand() % 100;}// 冒泡排序bubbleSort(arr, n);// 打印排序结果printf("排序结果：\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");// 释放内存free(arr);return 0;}```3. 性能分析（1）对于随机生成的数组，冒泡排序的平均性能较好，时间复杂度为O(n^2)。
1冒泡排序的ARM汇编程序
1冒泡排序的ARM汇编程序ORG 09B0HQUE：MOV R3，#50H QUE1：MOV A，R3 MOV R0，AMOV R7，#0AHCLR 00HMOV A，@R0Q12：INC R0MOV R2，ACLR CMOV 22H，@R0CJNE A，22H，Q13 SETB CQ13：MOV A，R2JC Q11SETB 00HXCH A，@R0DEC R0XCH A，@R0INC R0Q11：MOV A，@R0 DJNZ R7，Q12JB 00H，QUE1SJMP $END2 ARM汇编希尔排序法对10个带符号数进行排序Code:void shell(int src[],int l,int r){int ih;r++;for(ih=1;ih<(r-l)/9;ih=ih*3+1);//eax,ih//ebx,il//ecx,ir//edx,cmps_asm{push eaxpush ebxpush ecxpush edxpush esipush edi;貌似这堆进栈用处不大哎mov edi,srcmov eax,dword ptr [ih]LIH:cmp eax,0jna EXIHmov ebx,eaxdec ebxLLH:cmp ebx,dword ptr [r]jnb EXLLHmov ecx,ebxmov edx,dword ptr [edi+ecx*4]LCMP:mov esi,eaxdec esicmp ecx,esijna EXCMPpush ecxsub ecx,eaxcmp edx,dword ptr [edi+ecx*4] pop ecxjnb EXCMPpush ebxpush ecxsub ecx,eaxmov ebx,dword ptr [edi+ecx*4] pop ecxmov dword ptr [edi+ecx*4],ebx pop ebxsub ecx,eaxjmp LCMPEXCMP:mov dword ptr [edi+ecx*4],edx inc ebxjmp LLHEXLLH:push ecxmov ecx,3push edxcdqidiv ecxpop edxpop ecxjmp LIHEXIH:pop edipop esipop edxpop ecxpop ebxpop eax}}351单片机C语言对流水灯编程,用定时中断做#include<reg52.h>define uchar unsigned charuchar m=0,i=0;void main(){ TMOD|=0x01; //定时器0工作方式为1TH0=(65536-50000)/256; //装初值TL0=(65536-50000)%256; EA=1; //开总中断ET0=1; //开定时器中断TR0=1; //开启定时器while(1); //等待中断}void timer0() interrupt 1{TH0=(65536-50000)/256;TL0=(65536-50000)%256; m++ ;if(m==5) //12M晶振定时5*50MS=250MS{m=0;P1=~(0X01<<i);//P1接8个LEDif(++i==8) i=0;}}4单片机编程C语言和汇编都可以。
单片机与接口技术实验报告--冒泡排序实验
本科实验报告课程名称：单片机原理与接口技术实验项目：冒泡排序实验实验地点：跨越机房专业班级：学号：学生姓名：指导教师：2012 年4 月10 日一、实验目的和要求（1）熟悉MCS-51指令系统，掌握程序设计方法。
（2）掌握排序程序算法。
（3）掌握用循环程序实现数据排序的基本方法。
二、实验内容和原理编写并调试一个通用排序子程序，其功能为将RAM的40H~4FH单元的16字节无符号二进制整数按从小到大顺序排列，将排序后数据存储于RAM的50H~5FH单元中。
三、主要仪器设备计算机一台；伟福6000四、操作方法与实验步骤（上机源程序）ORG 0000H;该段代码向数据区域40H~4FH写入20H~11HMOV R7,#10H ;数据长度→R7MOV R0,#40H ;首地址→R0MOV R1,#20H ;第一个数据→R1START: MOV A,R1 ;(R1)→AMOV @R0,A ;数据→对应地址INC R0 ;地址加1DEC R1 ;数据减1DJNZ R7,START ;判断赋值完成否MOV R7,#0FH ;数据长度-1→R7LP0: MOV R0,#40H ;数据区域首地址→R0MOV A,R7 ;(R7)→AMOV R6,A ;(R7)→R6CLR 7FH ;设定7FH位为flag,并且flag=0LP1: MOV A,@R0 ;取得数据→AMOV 20H,@R0 ;当前地址中的值暂存到20H中INC R0 ;地址加1MOV 21H,@R0 ;当前地址中的值暂存到21H中CLR C ;清CSUBB A,21H ;相邻两个数相减JC LP2 ;如果前者大于后者则交换相邻的数SETB 7FH ;flag=1MOV @R0,21H ;把前边的数赋给后一个地址DEC R0 ;地址减1MOV @R0,21H ;把后边的数赋给前一个地址INC R0 ;地址加1LP2: DJNZ R6,LP1 ;判断是否到达内循环次数JNB 7FH,LP3 ;判断是否flag=0.如果flag=0，则表示顺序已经排好DJNZ R7,LP0 ;判断是否到达外循环次数LP3: MOV R7,#10H ;获得要传输的数据个数;把40H~4FH单元中数据复制到50H~5FH单元中MOV R0,#40H ;40H→R0MOV R1,#50H ;50H→R1LP4: MOV A,@R0 ;((R0))→AMOV @R1,A ;(A)→(R1)INC R0 ;地址加1INC R1 ;地址加1DJNZ R7,LP4 ;判断赋值是否完成SJMP $ ;程序在此处死循环END五、实验数据记录和处理单步执行观察发现，每一个数都会逐次与它之后的数进行比较，排序，直到所有数据都与其后的数据比较排完后才结束。
arm汇编之冒泡排序
arm汇编之冒泡排序开始在ADS里面写程序后，发现自己之前对于X86汇编的学习完全归还给了我的老师门。
最直接的便是要写一个从小到大的冒泡排序。
冒泡排序的思想我想就不用赘述了。
以前c语言遍的应该很多了。
算法不成问题，可是数据结构知道是数组，可是数组在arm汇编里面该在怎么定义了？其实，还真感觉又要从零开始了。
X86的汇编已经完全归还给了我敬爱的微机原理老师。
网上看到了一个广为流传的冒泡排序，既然写不出来，那就先学习它的精髓，说不定还能为我所用了。
代码详细的看了看。
具体翻译如下：AREA Sort,CODE,READONLY ：首先用AREA伪代码加上CODE，表明下面引出的将是一个代码段，ENTRY 和END成对出现，说明他们之间的代码是程序的主体ENTRY：表示代码的开始Start MOV r4,#0 ：将0赋值给r4LDR r6,=src ：在使用LDR时，当格式是LDR r0,=0x022248，则第二个参数表示地址，即0x022248，同样的，当src变量代表一个数组时，需要r0寄存器指向src 则需要这样赋值：LDR r0,=src 当格式是LDR r0,[r2]，则第二个参数表示寄存器，我的理解是符号表示取内容，r2本身表示一个寄存器地址，取内容候将其存取r0这个寄存器中跳转到LDR R0,[R1]将存储器地址为R1的字数据读入寄存器R0 LDRR0,[R1,#8]将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1+8写入R1，此句是将数据src的首地址赋值给R6ADD r6,r6,#len：R6为数组的最后一个数组元素的地址。
数组这时是连续分配的。
Outer LDR r1,=src：将src地址即数组元素首地址赋值给R1Inner LDR r2,[r1] ：将存储器地址为r1的字数据读入r2 LDR r3,[r1,#4]：将存储器地址为R1+4的字数据读入R3 CMP r2,r3 ：比较R2,R3STRGT r3,[r1]：若大于，则将R3中的字数据写入以R1为地址的存储器中STRGT r2,[r1,#4]：若大于，则将R2中的字数据写入以R1+4为地址的存储器中ADD r1,r1,#4：R1+4赋值给R1 CMP r1,r6：R1与R6比较BLT Inner：若是有符号数小于，即R1<R6，则跳转到Inner行执行ADD r4,r4,#4：R4+4赋值给R4 CMP r4,#len：R4与len比较SUBLE r6,r6,#4 ：若有符号数小于或等于，则R6-4赋值给R6 BLE Outer ：若有符号数小于或等于，则跳转到OuterStop MOV r0,#0x18 ， stop一段是用来是程序退出的，第一个语句“MOV r0，#0x18”将r0赋值为0x18，这个立即数对应于宏angel_SWIreason_ReportException。
单片机与接口技术实验报告冒泡排序实验
单片机与接口技术实验报告冒泡排序实验本实验旨在通过单片机的接口技术，实现冒泡排序算法的实践与理解。
通过实际操作，掌握单片机与接口技术的基本应用，理解冒泡排序算法原理，提升实践能力和编程技能。
冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
在单片机与接口技术的实验中，我们可以使用LED灯等外部设备来模拟冒泡排序的过程。
通过改变LED灯的亮灭状态，反映出排序过程中数据的交换结果。
确定单片机型号并连接硬件电路。
选择合适的单片机，如8051系列，并搭建相应的硬件电路。
主要包括电源、晶振、输入输出端口、LED灯等。
编写程序代码。
根据冒泡排序算法，编写适用于所选单片机的程序代码。
代码应该能够控制LED灯，根据排序结果改变其亮灭状态。
调试与运行程序。
将程序下载到单片机中，开启电源，观察LED灯的亮灭情况。
检查程序是否能够正确地实现冒泡排序。
记录与分析实验结果。
详细记录LED灯的亮灭状态，分析排序结果是否正确。
同时，对程序进行优化，提高排序效率。
经过实验，我们成功地在单片机上实现了冒泡排序算法。
观察LED灯的亮灭情况，我们可以看到排序过程中的数据交换过程。
通过对比理论结果与实际结果，我们发现二者基本一致，说明我们的程序正确地实现了冒泡排序。
在实验过程中，我们遇到了一些问题，如初始时端口设置不正确导致LED灯无法正常显示、数据交换过程中出现异常等。
针对这些问题，我们通过查阅资料和讨论，对程序进行了相应的修改和优化，最终解决了问题。
通过本实验，我们不仅加深了对冒泡排序算法的理解，还掌握了单片机与接口技术的应用。
同时，实验过程中的问题也锻炼了我们的解决问题的能力。
本实验还提高了我们的实践能力和编程技能，为后续的学习和实践打下了坚实的基础。
汇编语言实验七实验报告
汇编语言实验七实验报告汇编语言实验七实验报告一、实验目的本次实验的目的是了解多重循环结构的编程技巧，并使用它们对数据进行排序和搜索。
二、实验内容本实验内容主要包括：1.使用多重循环结构实现数据的排序，如冒泡排序、快速排序等；2.使用多重循环结构实现数据的搜索，如线性搜索、二分搜索等；3.使用结构化编程实现控制结构，如条件判断、循环结构等来完成数据的排序和搜索。
三、实验过程1. 冒泡排序本实验使用多重循环结构，采用冒泡排序的方法，实现对一组数据的排序。
具体代码如下：.model tiny.stack 100h.dataarray dw 3, 1, 4, 0, 5, 2count dw 6temp dw ?.codemain procmov ax,@data mov ds,axmov ax,array mov si,axmov cx,count mov cl,2l1:mov di,simov bx,[di] inc dil2:mov ax,[di] cmp ax,bxjng l3mov temp,ax mov [di],bx mov bx,temp l3:inc diloop l2inc sidec cxjnz l1 ;循环结束 mov ax,countsub ax,2l4:mov di,simov ax,[di]mov bx,[di+2]cmp bx,axjng l5mov temp,axmov [di],bxmov [di+2],temp l5:inc sidec axjnz l4 ;循环结束 tmov ax,4c00hint 21hmain endpend main上述代码主要实现了多重循环结构，包括两个重复循环：一个用来对数据进行比较，另一个用来循环处理剩下的数据项，直到排序完成。
2. 线性搜索接下来实现线性搜索的功能，具体代码如下：.model tiny.stack 100h.dataarray dw 3, 1, 4, 5, 0, 2count dw 6key dw 4add dw 0.codemain procmov ax,@datamov ds,axmov ax,arraymov di,axmov cx,countl1:cmp [di], keyjne l3jmp l2l3:inc diloop l1l2:mov ax,add mov bx,count sub bx,1mul bxadd ax,key mov bx,2div bxinc axmov bx,4mul bxmov di,axmov ax,array add ax,dimov si,axmov ax,[si] mov bx,keyje l4mov ax,-1l4:mov ax,4c00hint 21hmain endpend main上述代码主要实现了线性搜索的功能，通过比较数组中的每一项与给定的关键字，如果相同，则记录下该项的偏移量，然后根据偏移量计算出索引，最终返回数组中搜索到的数据。
排序算法实验报告2：冒泡排序及选择排序(分割策略)
排序算法实验报告2：冒泡排序及选择排序(分割策略)1. 引言本实验旨在研究和分析冒泡排序和选择排序算法，并通过对比它们的性能来评估它们在排序过程中的效率和效果。
冒泡排序和选择排序都是经典的排序算法，它们在不同的场景下都有着广泛的应用。
2. 冒泡排序2.1 算法原理冒泡排序是一种通过比较和交换相邻元素来排序的算法。
它的基本思想是重复地遍历待排序序列，每次比较相邻的两个元素，并根据排序规则对它们进行交换，直到整个序列有序。
2.2 算法实现冒泡排序的算法实现可以分为以下几个步骤：1. 遍历待排序序列，从第一个元素开始，依次比较相邻的两个元素。
2. 如果相邻元素的顺序不符合排序规则，则交换它们的位置。
3. 继续遍历序列，重复以上步骤，直到整个序列有序。
2.3 算法性能冒泡排序的时间复杂度为O(n^2)，其中n是待排序序列的长度。
它是一种稳定的排序算法。
3. 选择排序(分割策略)3.1 算法原理选择排序是一种通过选择最小（或最大）元素并将其放置到已排序序列的末尾（或开头）来排序的算法。
它的基本思想是将待排序序列划分为已排序和未排序两部分，每次从未排序部分选择最小（或最大）的元素，并将其加入到已排序部分。
3.2 算法实现选择排序的算法实现可以分为以下几个步骤：1. 遍历待排序序列，先假定第一个元素为最小（或最大）元素。
2. 将该元素与未排序部分的元素依次比较，找到最小（或最大）的元素。
3. 将最小（或最大）元素与未排序部分的第一个元素交换位置，将其加入到已排序部分。
4. 继续遍历未排序部分，重复以上步骤，直到整个序列有序。
3.3 算法性能选择排序的时间复杂度为O(n^2)，其中n是待排序序列的长度。
它是一种不稳定的排序算法。
4. 实验结果与分析通过对冒泡排序和选择排序的实验，我们得到了它们在不同规模的输入数据下的排序时间。
根据实验结果，我们可以发现：- 冒泡排序相对于选择排序来说，其性能较差。
在相同规模的输入数据下，冒泡排序的排序时间要长于选择排序。
汇编语言实现整数冒泡排序
第三次实验报告1.实现正整数的冒泡排序，要求有输入与输出。
实验源程序;LT413.ASM.model small.stack.datacount = 10array dw count dup(0)wtemp dw ?flg db 0.code.startupmovcx,countmovbx,offset arrayagaini: call readmov [bx],axincbxincbxcalldpcrlfiloopagaini;;movcx,countdec cxoutlp:mov flg,0movdx,cxmovbx,offset arrayinlp: mov ax,[bx]cmp ax,[bx+2]jna nextxchg ax,[bx+2]mov flg,1mov [bx],axnext: incbxincbxjnzinlpcmp flg,0jzfxwloopoutlp;;fxw:movcx,countmovbx,offset array againo: mov ax,[bx]movwtemp,axcall writeincbxincbxcalldpcrlfoloopagaino.exit 0read procpushbxpush cxpush dxxorbx,bxxorcx,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,1movdx,bxshl bx,1addbx,dx;mov ah,0addbx,axjmp read1read3: cmp cx,0jz read4negbxread4: movax,bxpop dxpop cxpopbxretread endp dpcrlfi procpush axpush dxmov ah,2mov dl,0dhint 21hmov ah,2mov dl,0ahint 21hpop dxpop axretdpcrlfi endpwrite procpush axpushbxpush dxmovax,wtemptestax,axjnz write1mov dl,'0'mov ah,2int 21hjmp write5 write1: jns write2 movbx,axmov dl,'-'mov ah,2int 21hmovax,bxneg axwrite2: mov bx,10pushbxwrite3: cmp ax,0jz write4subdx,dxdivbxadd dl,30hpush dxjmp write3write4: pop dxcmp dl,10je write5mov ah,2int 21hjmp write4write5: pop dxpopbxpop 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.datastring1db 'Mean1 use register :','$'string2db 'Mean2 use variable :','$'string3db 'Mean3 use stack :','$'string4db 0dh,0ah,'$'mydatadw 1992hwordTEMPdw ?.code.startup;AX方式movdx,offset string1;mov ah,9;int 21h;movax,wordptrmydata;call chan1;;变量方式push axmovdx,offset string4;mov ah,09h;int 21h;movdx,offset string2;mov ah,09h;int 21h;pop axmov word ptrwordTEMP,ax;call chan2;;栈方式push axmovdx,offset string4;mov ah,09h;int 21h;movdx,offset string3;mov ah,09h;int 21h;pop axpush ax;call chan3;pop ax;.exit 0chan1 procpush ax;pushbx;movbl,al;moval,ah;callALdisp;moval,bl;callALdisp;popbx;pop ax;retchan1 endpchan2 proc;wordTEMP传递push ax;pushbx;movbl,al;moval,ah;callALdisp;moval,bl;callALdisp;pop ax;retchan2 endpchan3 proc;栈传递pushbp;movbp,sp;push ax;pushbx;mov ax,[bp+4];movbl,al;moval,ah;callALdisp;moval,bl;callALdisp;popbx;pop ax;popbp;retchan3 endpALdisp procpush axpush cxpush dxpush axmovdl,almov cl,4shrdl,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实验结果：。
arm汇编之冒泡排序
arm汇编之冒泡排序AREA Sort,CODE,READONLY ：首先用AREA伪代码加上CODE，表明下面引出的将是一个代码段（于此相对的还有数据段DATA），ENTRY 和END成对出现，说明他们之间的代码是程序的主体ENTRY：表示代码的开始Start MOV r4,#0 ：将0赋值给r4LDR r6,=src ：在使用LDR时，当格式是LDR r0,=0x022248，则第二个参数表示地址，即0x022248，同样的，当src变量代表一个数组时，需要r0寄存器指向src则需要这样赋值：LDR r0,=src 当格式是LDR r0,[r2]，则第二个参数表示寄存器，我的理解是[]符号表示取内容，r2本身表示一个寄存器地址，取内容候将其存取r0这个寄存器中跳转到LDR R0,[R1]将存储器地址为R1的字数据读入寄存器R0 LDRR0,[R1,#8]将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1+8写入R1，此句是将数据src的首地址赋值给R6ADD r6,r6,#len：R6为数组的最后一个数组元素的地址。
数组这时是连续分配的。
Outer LDR r1,=src：将src地址即数组元素首地址赋值给R1Inner LDR r2,[r1] ：将存储器地址为r1的字数据读入r2 LDR r3,[r1,#4]：将存储器地址为R1+4的字数据读入R3CMP r2,r3 ：比较R2,R3STRGT r3,[r1]：若（有符号数）大于，则将R3中的字数据写入以R1为地址的存储器中STRGT r2,[r1,#4]：若大于，则将R2中的字数据写入以R1+4为地址的存储器中ADD r1,r1,#4：R1+4赋值给R1CMP r1,r6：R1与R6比较BLT Inner：若是有符号数小于，即R1<R6，则跳转到Inner行执行ADD r4,r4,#4：R4+4赋值给R4CMP r4,#len：R4与len比较SUBLE r6,r6,#4 ：若有符号数小于或等于，则R6-4赋值给R6BLE Outer ：若有符号数小于或等于，则跳转到OuterStop MOV r0,#0x18 ， stop一段是用来是程序退出的，第一个语句“MOV r0，#0x18”将r0赋值为0x18，这个立即数对应于宏angel_SWIreason_ReportException。
计算机组成原理和汇编语言实验报告
计算机组成原理和汇编语言实验报告专业班级：计算机0801班实验一、汇编：冒泡排序1、实验内容：定义一个字数组序列：1567，25，46，4560，678，1234，32540。
用冒泡排序对该数组由小到大排序，并将排序结果以十进制数字的形式在屏幕上显示出来。
2、实验原理：程序首先定义了要排序的数组，然后对其在原数组内进行冒泡排序。
冒泡排序是基于交换排序的一种算法，它依次两两比较待排序的元素，若为逆序则进行交换。
每趟冒泡都将待排元素序列中的最大量交换到最后位置。
冒泡过程共需进行n(n-1)/2次比较，直到全部元素有序为止。
数组有序以后，进行输出的工作。
依次从小到大，将元素转换为十进制数的ASCII码值来输出，并在输出每个数时，增加输出回车换行来使输出结果清晰。
3、实验代码：;-------------------------PROGRAM BEGINS---------------------------;----------------------------DEFINE DS-------------------------------DATA SEGMENTTIME DW 0 ;THE LOOP TIME OF THE OUTER LOOPCHU DW 10 ;USED TO CONVERT THE NUM TO DECIMAL DTY DW 1567,25,46,4560,678,1234,32540 ,'$' ;DEFINE THE ARRARYRESULT DB ?DATA ENDS;-----------------------------DEFINE CS-----------------------------CODE SEGMENT "CODE"ASSUME CS:CODE ,DS:DATASTART:MOV AX,DATAMOV DS,AXAGAIN:MOV CX, 6 ;THE LOOP NUM OF THE INER LOOP MOV BP,12 ;NUM OF THE BYTESAGAIN1:MOV AX,DTY[BP]CMP DTY[BP-2],AX ;CMP WITH THE FORMER BYTEJBE NEXT ;JMP IF BELOW OR EQUALXCHG AX,DTY[BP-2] ;IF ABOVE,THEN CHANGEXCHG AX,DTY[BP]NEXT:SUB BP,2 ;POINT TO THE FORMER ONEDEC CXCMP CX,TIME ;IS IT DONE?JE NEXT1 ;DONEJMP AGAIN1 ;NOT DONE YETNEXT1:INC TIMECMP TIME,6 ;IS IT DONE?JE NEXT3 ;DONEJMP AGAIN ;NOT DONE YETNEXT3:MOV TIME,0 ;RENEW THE DATAMOV BP,0CHANGE:MOV RESULT[5],13 ;FINISH OF THE NUMMOV RESULT[6],10MOV RESULT[7],'$'MOV AX,WORD PTR DTY[BP] ;THE DW TO OUTPUTMOV CX,5 ;LOOP NUMMOV BX,4 ;TWO BITS * 4 =WORD CHANGE1:MOV DX,0DIV CHU ;DX:AX/CHUMOV RESULT[BX],DL ;THE REMAINDERADD RESULT[BX],30H ;TO DECIMALDEC BX ;POINT TO THE FORMER TWO BITS LOOP CHANGE1MOV CX,4MOV BX,0FIND0:CMP RESULT[BX], '0' ;IS IT ZERO?JNE FINAL ;NOT ZEROADD BX,1 ;ZEROLOOP FIND0FINAL:LEA DX, RESULT[BX] ;OUTPUTMOV AH,09HINT 21HADD BP, 2 ;POINT TO NEXT WORDINC TIMECMP TIME,7 ;IS IT DONE?JNE CHANGE ;NOT NONEMOV AH,4CHINT 21HCODE ENDSEND START;--------------------PROGRAM ENDS--------------------实验二算术逻辑运算实验一、实验目的1．掌握简单运算器的组成以及数据传送通路。
ARM汇编-冒泡排序-实验报告
实验要求实现字符串冒泡排序。
实验过程首先在内存中定义字符串，使用的方法是AREA SORTDATA,DATA,READWRITEstr DCB "9847210356"len DCD 10DCB表示在内存中开辟一个byte的空间。
DCD则表示开辟一个word的空间采用两层循环来进行冒泡排序。
第一层循环首先把r1初始化为字符串首地址，把r5初始化为0，r5代表内循环执行次数。
然后把r4 减1，因为最后的一个字符已经排好序了。
如果r4 = 0, 代表排序已经完成，调到结束代码。
loop0MOV r1,r0 ;r1 is the start address of stringSUBS r4,r4,#1 ;r4 is the last index, the counterCMP r4,#0BEQ endMOV r5,#0第二层循环就是从左往右对字符进行交换，每次把r1和r5的值都增加1。
当r5=r4的时候就跳出循环，到达外层循环。
;in every loop, s value of contiguous two bytes from the start to start+r4;using r1 as the address,increment in every inner loop;using r2,r3 to load the two bytes then compare; if r3 is smaller than r2,;then store the val in s placeloopLDRB r2,[r1]LDRB r3,[r1,#1]CMP r2,r3STRGTB r2,[r1,#1]STRGTB r3,[r1]ADD r1,r1,#1ADD r5,r5,#1CMP r5,r4BNE loop;if reaches the end, branch to outer loopB loop0为了让字符从小到大排列，在CMP r2,r3后，连续使用STRGT(Store Greater Than)，如果r2>r3, 就分别把他们存进对方的地址实现交换。
arm汇编算法
ARM汇编语言是一种基于ARM架构的低级编程语言，广泛用于嵌入式系统和底层软件开发。
通过直接操作硬件资源，它能够高效地实现各种算法，从简单的数据处理到复杂的加密解密算法。
下面我将介绍一个使用ARM汇编语言实现的经典算法——冒泡排序。
冒泡排序是一种简单的排序算法，通过反复交换相邻的未排序元素，使得最大（或最小）的元素像气泡一样逐渐“浮”到数列的一端。
在ARM汇编语言中，我们可以使用循环结构和条件语句来实现这一算法。
首先，我们需要定义待排序的数据数组和相关的变量。
然后，使用嵌套的循环结构，外层循环控制排序的轮数，内层循环负责两两比较并交换元素。
通过比较相邻元素的大小，如果顺序不对则交换它们的位置。
这个过程会一直重复，直到整个数组变得有序。
在ARM汇编语言中，我们可以使用寄存器来存储待比较的元素，使用条件语句来判断它们的大小关系，然后使用数据交换指令来交换它们的位置。
通过这种方式，我们可以高效地实现冒泡排序算法，并且对硬件资源的占用也非常有限。
需要注意的是，由于ARM汇编语言是一种低级语言，编程时需要仔细考虑内存访问、寄存器分配和指令流水线等因素，以确保程序的正确性和高效性。
此外，为了提高算法的效率，还可以使用一些优化技巧，如减少不必要的比较次数和利用已排序的子序列等。
总的来说，ARM汇编语言在算法实现方面具有很强的灵活性和高效性。
通过使用适当的数据结构和算法技巧，我们可以编写出高效且可靠的程序来满足各种实际需求。
微机原理-实验一-汇编语言-冒泡排序
微机原理实验报告班级：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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验要求
实现字符串冒泡排序。
实验过程
首先在内存中定义字符串，使用的方法是
AREA SORTDATA,DATA,READWRITE
str DCB "9847210356"
len DCD 10
DCB表示在内存中开辟一个byte的空间。
DCD则表示开辟一个word的空间
采用两层循环来进行冒泡排序。
第一层循环首先把r1初始化为字符串首地址，把r5初始化为0，r5代表内循环执行次数。
然后把r4 减1，因为最后的一个字符已经排好序了。
如果r4 = 0, 代表排序已经完成，调到结束代码。
loop0
MOV r1,r0 ;r1 is the start address of string
SUBS r4,r4,#1 ;r4 is the last index, the counter
CMP r4,#0
BEQ end
MOV r5,#0
第二层循环就是从左往右对字符进行交换，每次把r1和r5的值都增加1。
当r5=r4的时候就跳出循环，到达外层循环。
;in every loop, swap the value of contiguous two bytes from the start to start+r4
;using r1 as the address,increment in every inner loop
;using r2,r3 to load the two bytes then compare; if r3 is smaller than r2,
;then store the val in swapped place
loop
LDRB r2,[r1]
LDRB r3,[r1,#1]
CMP r2,r3
STRGTB r2,[r1,#1]
STRGTB r3,[r1]
ADD r1,r1,#1
ADD r5,r5,#1
CMP r5,r4
BNE loop
;if reaches the end, branch to outer loop
B loop0
为了让字符从小到大排列，在CMP r2,r3后，连续使用STRGT(Store Greater Than)，如果r2>r3, 就分别把他们存进对方的地址实现交换。
程序执行到底，可以看到字符均已经排好序。
实验结论
通过本次实验，我对ARM汇编的基本指令更加了解了，知道了简单的分支指令，条件指令和访存指令的使用方法。