微机原理冒泡排序

合集下载

微机原理实验报告冒泡法对数据排序8页

微机原理实验报告冒泡法对数据排序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语言中的数组和循环结构等基本语言要素,完成了对数组中的数据进行排序
的操作。

通过本次实验,我们深入了解了算法的实际应用,掌握了编程语言的基本技巧,
对于今后的学习和实践具有重要的意义。

冒泡排序知识点总结

冒泡排序知识点总结

冒泡排序知识点总结冒泡排序的时间复杂度为O(n^2),它在实际应用中很少用到,因为它效率低下,但是它仍然是一个重要的排序算法,它有助于我们理解排序算法的基本思想和原理。

冒泡排序的基本思想是比较相邻的两个元素,如果它们的顺序错误就交换它们的位置,直到整个列表都是按照从小到大(或从大到小)的顺序排列为止。

下面我们来详细探讨冒泡排序的知识点:1. 原理及基本思想冒泡排序的基本思想就是通过不断地比较相邻的元素来逐步地将最大(或最小)的元素"浮"到最顶端。

在每一轮遍历中,都会依次比较相邻的两个元素,如果它们的顺序错误就把它们交换位置,直到整个列表都是按照从小到大(或从大到小)的顺序排列为止。

冒泡排序的基本思路:1)比较相邻的元素。

如果第一个比第二个大,就交换它们的位置;2)对每一对相邻的元素重复这个过程,直到没有任何一对元素需要交换为止。

冒泡排序的具体步骤:1)从第一个元素开始,重复遍历列表中的每一个元素;2)比较相邻的两个元素,如果它们的顺序错误就交换它们的位置;3)重复执行以上步骤,直到整个列表都是按照从小到大(或从大到小)的顺序排列。

2. 时间复杂度冒泡排序的最坏情况下时间复杂度为O(n^2),平均情况下也为O(n^2)。

因此,冒泡排序通常不是一个很好的选择,它的效率比较低,尤其是在处理大规模的数据时。

在冒泡排序的过程中,重复地比较相邻的元素并交换,最多需要进行n-1轮遍历,每一轮遍历的时间复杂度为O(n),因此总的时间复杂度为O(n^2)。

冒泡排序的最好情况下时间复杂度为O(n),即当列表已经是按照从小到大(或从大到小)的顺序排列时,只需要进行一次遍历,不需要交换任何元素。

3. 稳定性冒泡排序是一种稳定的排序算法,即相同值的元素在排序后相对位置不变。

因为在冒泡排序的过程中,只有相邻的元素之间交换位置,不会改变相同值元素的相对顺序。

4. 优化虽然冒泡排序的时间复杂度较高,但是我们可以通过一些优化来提高性能。

冒泡排序基本原理

冒泡排序基本原理

冒泡排序基本原理冒泡排序是一种简单且常用的排序算法,它的基本原理是通过重复地比较相邻的元素并交换位置,使得每一轮循环都能将最大(或最小)的元素“浮”到数组的一端。

下面就让我们来详细了解一下冒泡排序的基本原理。

1. 基本思想冒泡排序的基本思想是通过相邻元素的比较和交换来实现排序。

具体步骤如下:- 从数组的第一个元素开始,依次比较相邻的两个元素,如果前一个元素大于后一个元素,则交换它们的位置;- 继续比较下一个相邻元素,重复上述操作,直到最后一个元素;- 一轮比较结束后,最大(或最小)的元素就“冒泡”到了数组的最后位置;- 针对剩下的未排序元素,重复上述操作,直到所有元素都排序完成。

2. 示例演示为了更好地理解冒泡排序的原理,我们来看一个简单的示例。

假设有一个待排序数组arr,其元素依次为[5, 2, 8, 3, 1]。

按照冒泡排序的步骤,我们可以进行如下操作:- 第一轮比较:比较[5, 2, 8, 3, 1]中的相邻元素,交换5和2的位置,得到[2, 5, 8, 3, 1];继续比较后面的元素,得到[2, 5, 3, 8, 1];最后一次比较得到[2, 5, 3, 1, 8],此时最大的元素8已经“冒泡”到了最后位置;- 第二轮比较:比较[2, 5, 3, 1]中的相邻元素,交换5和3的位置,得到[2, 3, 5, 1];继续比较后面的元素,得到[2, 3, 1, 5],此时第二大的元素5已经“冒泡”到了倒数第二位置;- 第三轮比较:比较[2, 3, 1]中的相邻元素,交换3和1的位置,得到[2, 1, 3];此时第三大的元素3已经“冒泡”到了倒数第三位置;- 第四轮比较:比较[2, 1]中的相邻元素,交换2和1的位置,得到[1, 2];此时第四大的元素2已经“冒泡”到了倒数第四位置;- 第五轮比较:只有一个元素,无需比较。

3. 时间复杂度冒泡排序的时间复杂度为O(n^2),其中n为待排序数组的长度。

微机原理实验 冒泡法排序

微机原理实验 冒泡法排序
LOOP OUTP
POP SI ;恢复寄存器
POP DX
POP CX
POP BX
POP AX
RET ;子程序返回
JZ DONE ;回车结束程序
CMP AL,'0' ;不是0~9之间的字符,则转入出错
JB ERROR
CMP AL,'9'
JA ERROR
SUB AL,30H ;将ASCII码字符变为对应的数字
Output ENDP
CODE ENDS
END START
DIV SI ;AX中的数除以10
PUSH DX ;余数入栈
INC CX
CMP AX,0 ;商为0则完成转换
MOV BX,4 ;送大循环的次数,比较的趟数
SORT:MOV CX,BX ;送小循环的次数,每趟比较的次数
MOV SI,OFFSET ARRAY ;取数组的偏移量送SI
COMP: MOV AX,[SI] ;送数组中第n个数
DATA SEGMENT
ARRAY DW 5 DUP(?) ;预留5个数据存储空间
DATA ENDS
CODE SEGMENT
ASSUME DS:DATA,CS:CODE
MAIN PROC
START: MOV AX,DATA
MOV DS,AX
XOR BX,BX
XOR CX,CX
XOR DX,DX
MOV SI,10 ;送乘数
NEXTI: MOV AH,01
INT 21H ;接收键盘的数字
CMP AL,0DH ;判断是否是回车
CMP AX,[SI+2] ;比较数组中第n个数和n+1个数

冒泡排序的规律

冒泡排序的规律

冒泡排序的规律
(最新版)
目录
1.冒泡排序的基本原理
2.冒泡排序的实现过程
3.冒泡排序的规律
4.冒泡排序的优缺点
正文
1.冒泡排序的基本原理
冒泡排序是一种简单的排序算法,它通过不断比较和交换相邻的元素,使较大(或较小)的元素逐渐从前往后(或从后往前)移动,直到整个序列有序。

这个过程就像气泡在水中上升一样,因此被称为冒泡排序。

2.冒泡排序的实现过程
冒泡排序可以分为两个步骤:一是从序列的第一个元素开始,比较相邻的两个元素,如果前一个元素大于(或小于)后一个元素,则交换它们的位置;二是在第一步的基础上,继续比较剩余元素,直到序列的最后一个元素。

这样一轮比较下来,序列中最大的元素就会被放到最后的位置。

接下来,对序列中剩余的元素重复执行以上步骤,直到整个序列有序。

3.冒泡排序的规律
冒泡排序的规律主要体现在以下几个方面:
- 在每一轮比较中,较大的元素会逐渐从前往后移动;
- 在每一轮比较后,序列中最大的元素会被放到最后的位置;
- 随着轮次的增加,序列中的元素逐渐减小(或增大),直到整个序
列有序。

4.冒泡排序的优缺点
冒泡排序的优点是简单易懂,实现起来较为容易。

然而,它的缺点也比较明显,比如效率较低,尤其是在大规模数据集合上;另外,冒泡排序只能对有序或部分有序的数据集合进行排序,对于完全无序的数据集合,其性能较差。

冒泡排序算法原理

冒泡排序算法原理

冒泡排序算法原理冒泡排序是一种简单的排序算法,它通过重复比较相邻的两个元素,并根据大小交换位置,从而将最大(或最小)的元素逐渐“冒泡”到正确的位置。

冒泡排序的原理可以用以下步骤来描述:1. 比较相邻元素:从第一个元素开始,比较它和下一个元素的大小。

如果前一个元素大于后一个元素,则交换它们的位置;否则,保持不变。

2. 单次遍历:经过一次遍历后,最大(或最小)的元素已经“冒泡”到了最后的位置。

因此,在下一次遍历中,我们只需要比较前面n-1个元素即可。

3. 多次遍历:重复以上步骤,直到所有元素都排序完成。

每次遍历都会将当前未排序元素中的最大(或最小)值“冒泡”到最后。

冒泡排序的实现可以用如下伪代码表示:```function bubbleSort(arr):n = arr.lengthfor i from 0 to n-1:for j from 0 to n-i-1:if arr[j] > arr[j+1]:swap(arr[j], arr[j+1])```冒泡排序的时间复杂度为O(n^2),其中n表示待排序元素的个数。

在最坏情况下,即待排序元素已经按照逆序排列,冒泡排序需要进行n-1次遍历,每次遍历需要比较n-1次。

因此,总的比较次数为(n-1) + (n-2) + ... + 1 = (n-1)n/2,时间复杂度为O(n^2)。

虽然冒泡排序的时间复杂度较高,但它的实现简单直观,适用于小规模的数据排序。

此外,冒泡排序是一种稳定排序算法,即相等元素的相对位置在排序后不会发生改变。

冒泡排序的优化方法有以下几种:1. 提前终止:在每次遍历中,如果没有发生元素交换,说明已经完成排序,可以提前终止循环,减少不必要的比较次数。

2. 记录最后一次交换位置:在每次遍历中,记录最后一次元素交换的位置。

下一次遍历只需要比较到该位置即可,因为在该位置之后的元素已经有序。

3. 双向冒泡排序:在每次遍历中,同时从前向后和从后向前遍历,分别找到最大和最小元素,减少比较次数。

微机原理及接口技术实验——冒泡法

微机原理及接口技术实验——冒泡法

微机原理及接口技术实验——冒泡法冒泡排序是一种简单的排序算法,其基本思想是通过重复比较相邻的两个元素,并将较大的元素交换到右侧,从而将最大的元素逐渐"冒泡"到最右侧。

这种算法得名于每次比较时较大元素"冒泡"到右侧的过程。

冒泡排序算法的步骤如下: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行提示的错误。

冒泡排序算法的原理

冒泡排序算法的原理

冒泡排序算法的原理
冒泡排序算法是一种简单的比较排序算法,其原理是通过多次
遍历待排序的数列,每次遍历都将相邻的两个元素进行比较,如果
顺序不符合要求就交换它们的位置,直到整个数列都是按照从小到
大(或者从大到小)的顺序排列为止。

具体来说,冒泡排序算法的原理如下:
1. 首先,从数列的第一个元素开始,依次比较相邻的两个元素,如果前面的元素大于后面的元素,则交换它们的位置,这样一趟下来,最大(或最小)的元素就“沉”到了数列的最后面。

2. 然后,对剩下的未排序元素重复上述的比较和交换过程,直
到所有元素都排好序为止。

冒泡排序算法的时间复杂度为O(n^2),其中n为待排序数列的
长度。

在最坏的情况下,即待排序数列是逆序的情况下,冒泡排序
算法的时间复杂度达到最大值。

然而,在实际应用中,冒泡排序算
法并不是最优的选择,因为它的效率较低,尤其是对于大规模的数
据排序。

总的来说,冒泡排序算法的原理就是通过不断比较相邻元素并交换它们的位置,逐步将最大(或最小)的元素“沉”到数列的底部,直到整个数列都有序为止。

冒泡算法原理

冒泡算法原理

冒泡算法原理
冒泡排序是一种简单的排序算法,它会多次遍历待排序的列表,每次将相邻的元素进行比较并进行交换,从而将最大(或最小)的元素逐渐“冒泡”到列表的末尾。

冒泡排序的基本原理是:
1. 首先比较列表中第1个和第2个元素,如果第1个比第2个大(或小),则交换它们的位置。

2. 接下来比较第2个和第3个元素,以此类推,直到比较到倒数第2个元素和最后一个元素。

3. 这样一轮比较下来,列表中最大(或最小)的元素就“冒泡”到了末尾。

4. 重复以上步骤,每次比较的元素个数减少1,直到列表中所有元素都排好序。

冒泡排序的核心思想是通过相邻元素的比较和交换来实现元素的排序,在每一轮比较中,较大(或较小)的元素会逐渐“冒泡”到列表的末端,因此称之为冒泡排序。

冒泡排序的时间复杂度为O(n^2),其中n为待排序列表的长度。

尽管冒泡排序的效率并不高,但它的实现简单直观,适用于小规模的排序任务。

冒泡排序的排序原理和算法

冒泡排序的排序原理和算法

冒泡排序的排序原理和算法冒泡排序是一种简单且常用的排序算法,它的原理很简单,即通过相邻元素之间的比较和交换来实现排序。

冒泡排序的算法也很容易理解和实现,是初学者学习排序算法的重要一步。

冒泡排序的原理是通过不断地比较相邻的元素,如果前面的元素大于后面的元素,则交换它们的位置,这样每一轮比较都会将最大的元素“冒泡”到最后。

经过n-1轮的比较和交换后,就可以得到一个有序的数列。

具体来说,冒泡排序的算法步骤如下:1. 首先,比较相邻的两个元素,如果前面的元素大于后面的元素,则交换它们的位置;2. 继续比较下一对相邻元素,重复上述的比较和交换操作;3. 重复执行步骤2,直到最后一对相邻元素进行比较为止;4. 重复执行步骤1到步骤3,直到所有元素都排序完成。

冒泡排序的时间复杂度是O(n^2),其中n是待排序数列的长度。

这是因为冒泡排序的每一轮比较都需要扫描所有的元素,总共需要进行n-1轮比较,每一轮比较需要进行n次操作。

冒泡排序的优点是原理简单,易于理解和实现。

但是由于它的时间复杂度较高,在处理大规模数据时效率较低。

因此,在实际应用中,冒泡排序往往不是第一选择,更常用的是快速排序、归并排序等更高效的排序算法。

冒泡排序的应用场景相对较少,一般用于对小规模数据进行排序。

它的主要优点是代码简单易懂,适合初学者学习和理解排序算法的原理。

除此之外,在某些特定的场景下,冒泡排序也可以发挥一定的作用。

总结一下,冒泡排序是一种简单但效率较低的排序算法。

它的原理是通过相邻元素的比较和交换来实现排序,时间复杂度为O(n^2)。

冒泡排序适用于小规模数据的排序,但在处理大规模数据时效率较低。

了解冒泡排序的原理和算法对于学习和理解排序算法有一定的帮助,同时也为后续学习更高效的排序算法打下基础。

简述冒泡排序基本原理和算法流程

简述冒泡排序基本原理和算法流程

简述冒泡排序基本原理和算法流程下载温馨提示:该文档是我店铺精心编制而成,希望大家下载以后,能够帮助大家解决实际的问题。

文档下载后可定制随意修改,请根据实际需要进行相应的调整和使用,谢谢!并且,本店铺为大家提供各种各样类型的实用资料,如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等,如想了解不同资料格式和写法,敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!冒泡排序(Bubble Sort)是排序算法里面比较简单的一个排序。

微机原理实验报告冒泡法对数据排序

微机原理实验报告冒泡法对数据排序

实验内容:用“冒泡“法对一组数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,09HINT 21HLEA 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,09HINT 21HPOP 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 21HDEC 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 BX PUSH DX ADD AL,30H MOV DL,AL MOV AH,2 INT 21H POP DX MOV AX,DX MOV BX,10 MOV DX,0 DIV BX PUSH DX ADD AL,30H MOV DL,AL MOV AH,2 INT 21H POP DX ADD DX,30H MOV 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,DX MOV BX,10 MOV DX,0 DIV BX PUSH DX ADD AL,30H MOV DL,AL MOV AH,2 INT 21H POP DX ADD DX,30H MOV AH,2 INT 21H LEA DX,DT9 MOV AH,09H INT 21H RETZIXU1 ENDPCODE ENDSEND STAT调试中出现的一些问题:1.输入时不慎将字母O当数字0输入,结果导致了下面第5行提示的错误。

冒泡排序原理

冒泡排序原理

冒泡排序原理
冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。

走访元素的工作是重复地进行,直到没有相邻元素需要交换,也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。

冒泡排序算法的原理如下:
1.比较相邻的元素。

如果第一个比第二个大,就交换他们两个。

2.对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。

在这一点,最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤,除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

四川大学微机原理冒泡法排序实验报告

四川大学微机原理冒泡法排序实验报告

《微机原理与接口技术实验报告》学院:电气信息学院班级:电力老师:学号:姓名:目录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.当输入不合法时,显示如下:六、实验心得:在本次汇编语言程序设计实验中,我们运用了循环结构对冒泡排序进行了汇编设计。

冒泡排序

冒泡排序

冒泡排序冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。

走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名。

由于冒泡排序简洁的特点,它通常被用来对于计算机程序设计入门的学生介绍算法的概念。

冒泡排序算法的运作如下:(从后往前)1、比较相邻的元素。

如果第一个比第二个大,就交换他们两个。

2、对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。

在这一点,最后的元素应该会是最大的数。

3、针对所有的元素重复以上的步骤,除了最后一个。

4、持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

冒泡排序就是把小的元素往前调或者把大的元素往后调。

比较是相邻的两个元素比较,交换也发生在这两个元素之间。

所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

PHPfunctionbubbleSort($numbers){$cnt=count($numbers);for($i=0;$i<$cnt-1;$i++){//循环比较for($j=$i+1;$j<$cnt;$j++){if($numbers[$j]<$numbers[$i]){//执行交换$temp=$numbers[$i];$numbers[$i]=$numbers[$j];$numbers[$j]=$temp;}}}return$numbers;}$num=array(20,40,60,80,30,70,90,10,50,0);var_dump(bubbleSort($num));//输出结果如下://array(10){[0]=>int(0)[1]=>int(10)[2]=>int(20)[3]=>int(30)[4]=>int(40)[5]=>int(50)[6 ]=>int(60)[7]=>int(70)[8]=>int(80)[9]=>int(90)}C#语言冒泡算法C#namespace数组排序{classProgram{staticvoidMain(string[]args){inttemp=0;int[]arr={23,44,66,76,98,11,3,9,7};#region该段与排序无关Console.WriteLine("排序前的数组:");foreach(intiteminarr){Console.Write(item+"");}Console.WriteLine();#endregionfor(inti=0;i<arr.Length-1;i++){#region将大的数字移到数组的arr.Length-1-ifor(intj=0;j<arr.Length-1-i;j++){if(arr[j]>arr[j+1]){temp=arr[j+1];arr[j+1]=arr[j];arr[j]=temp;}}#endregion}Console.WriteLine("排序后的数组:"); foreach(intiteminarr){Console.Write(item+"");}Console.WriteLine();Console.ReadKey();}}}Erlangbubble_sort(L)->bubble_sort(L,length(L)).bubble_sort(L,0)->L;bubble_sort(L,N)->bubble_sort(do_bubble_sort(L),N-1).do_bubble_sort([A])->[A];do_bubble_sort([A,B|R])->caseA<Boftrue->[A|do_bubble_sort([B|R])]; false->[B|do_bubble_sort([A|R])]end.C语言#include<stdio.h>#defineSIZE8void bubble_sort(int a[],int n);void bubble_sort(int a[],int n)//n为数组a的元素个数{inti,j,temp;for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++){if(a[i]>a[i+1])//数组元素大小按升序排列{temp=a[i];a[i]=a[i+1];a[i+1]=temp;}}}intmain(){int number[SIZE]={95,45,15,78,84,51,24,12};inti;bubble_sort(number,SIZE);for(i=0;i<SIZE;i++){printf("%d",number[i]);}printf("\n");}JAVApublicclassBubbleSortpublicvoidsort(int[]a){inttemp=0;for(inti=a.length-1;i>0;--i) {for(intj=0;j<i;++j){if(a[j+1]<a[j]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}}}JavaScriptfunctionbubbleSort(arr) {vari=arr.length,j; vartempExchangVal;while(i>0){for(j=0;j<i-1;j++){if(arr[j]>arr[j+1]){tempExchangVal=arr[j];arr[j]=arr[j+1];arr[j+1]=tempExchangVal;}}i--;}returnarr;}vararr=[3,2,4,9,1,5,7,6,8]; vararrSorted=bubbleSort(arr); console.log(arrSorted);alert(arrSorted);控制台将输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]并且弹窗;易语言数组= { 233, 1,5, 5, 6, 8, 7, 9, 41, 62, 2, 1, 3, 0 }c = 1b = 取数组成员数(数组).判断循环首(c >0)c = 0.变量循环首(1, b -1, 1, d).如果真(数组[d] > 数组[d + 1]) ' 此处用于,对两个数据进行对比,可以修改成,拼音,数字大小,文本长度,等等e = 数组[d]数组[d] = 数组[d + 1]数组[d + 1] = eb = dc = c + 1.如果真结束.变量循环尾().判断循环尾()BASIC语言Submaopao()Dimaa=Array(233,10086,31,15,213,5201314,427)DimiAsInteger,jAsIntegerFori=UBound(a)-1To0Step-1Forj=0ToiIfa(j)>a(j+1)Thena(j)=a(j)+a(j+1):a(j+1)=a(j)-a(j+1):a(j)=a(j)-a(j+1)'交换变量数值EndIfNextjNextiFori=0ToUBound(a)Printa(i)NextiEndSubObjective-C(void)bubbleSort:(NSMutableArray *)array{ int i, y; BOOL bFinish = YES; for (i = 1; i<= [array count] && bFinish; i++) { bFinish = NO; for (y = (int)[array count]-1; y>=i; y--) { if ([[array objectAtIndex:y] intValue] < [[array objectAtIndex:y-1] intValue]) { [array exchangeObjectAtIndex:y-1 withObjectAtIndex:y]; bFinish = YES; } } }}Pythonalist = [1,12,2,4,51,66,45,25,96,78,55,23] def bubbleSort(aList): aLen = len(aList) for key in xrange(aLen-1): for x in xrange(aLen - key -1): if aList[x] > aList[x+1]: aList[x], aList[x+1] = aList[x+1], aList[x] print(alist)bubbleSort(alist)print(alist)Go语言package mainimport ("fmt")const (LENGTH=8){ func main() { var tmp intnumber:=[]int {95, 45, 15, 78, 84, 51, 24, 12} for i := 0; i < LENGTH; i++ { for j:= LENGTH-1; j >i; j-- { if (number[j]<number[j-1]) { tmp=number[j-1] number[j-1]=number[j] number[j]=tmp } } } for i := 0; i < LENGTH; i++ { fmt.Printf("%d ", number[i]) } fmt.Printf("\n"); }}GO语言2Gofunc BubbleSort(values[] int) { flag := true vLen := len(values) for i := 0; i < vLen-1; i++ { flag = true for j := 0; j < vLen-i-1; j++ { if values[j] > values[j+1] { values[j], values[j+1] = values[j+1], values[j] flag = false //continue } } if flag { break } }}Perl#! /usr/bin/perl -w use strict; my @list = (1,3,6,12,8);bubble_sort(\@list, scalar @list);print "@list\n"; sub bubble_sort { my $arrays_ref = shift; my $num = shift; for (my $i = 0; $i < $num - 1; $i++) { for (my $j = 0; $j < $num - $i - 1; $j++) { if ($arrays_ref->[$j] > $arrays_ref->[$j+1]) { my $tmp = $arrays_ref->[$j]; $arrays_ref->[$j] = $arrays_ref->[$j+1];$arrays_ref->[$j+1] = $tmp; } } }PASCALvara:array[1..4]ofinteger;i,j,temp,n:integer;beginread(n);fori:=1tondoread(a[i]);fori:=1tondoforj:=1ton-idoifa[j]>a[j+1]thenbegintemp:=a[j];a[j]:=a[j+1];a[j+1]:=temp;end;fori:=1tondowrite(a[i]);end.Pythondefbubble(bubbleList):listLength=len(bubbleList) whilelistLength>0:foriinrange(listLength-1):ifbubbleList[i]>bubbleList[i+1]: bubbleList[i]=bubbleList[i]+bubbleList[i+1] bubbleList[i+1]=bubbleList[i]-bubbleList[i+1] bubbleList[i]=bubbleList[i]-bubbleList[i+1] listLength-=1printbubbleListif__name__=='__main__': bubbleList=[3,4,1,2,5,8,0]bubble(bubbleList)。

微机原理冒泡排序讨论课报告

微机原理冒泡排序讨论课报告

讨论课报告学校:上海电机学院班级:电子1313 学号:131003430326 姓名:吴限一、题目:在内存中以BUF为首地址存放着一个无序排列的无符号数组,这个无符号数组存放的是某次考试的学生成绩,要求对这个无符号数组按降序排序。

二、程序设计1.程序采用多重循环程序结构实现冒泡排序算法,表述编程思路(流程图)。

内循环实现什么功能?外循环实现什么功能?分析说明编程思路:先定义数据段,把数据存入BUF中,然后根据BUF中数据量的多少放入COUNT中来确定外循环次数。

再开始主程序,在主程序中对COUNT进行减一来完成内循环,比较相邻两数的大小,通过JNA来看标志位是否为1,若为1则不交换,否则交换并设置一个标记位。

标记位若为0则退出循环,否则进行下次循环。

流程图见附件。

功能:外循环来控制循环次数,内循环实现数据比较交换,内循环执行一次(CX)-1→CX,循环次数根据数据的量决定。

2.源程序安排几个段结构?分析说明。

由上述编程思路源程序安排3个段结构,分别是代码段,数据段,堆栈段。

数据段:通常是指用来存放程序中已初始化的全局变量的一块内存区域。

数据段属于静态内存分配。

此程序中数据段以BUF为首地址在DB中存放了要排序的数据表,并将数据个数放入COUNT中作为外循环次数。

代码段:通常是指用来存放程序执行代码的一块内存区域。

此程序中代码段包含了所有实现算法的指令性及指示性语句,实现了数据的循环排序功能。

堆栈段:通常是指采用堆栈方式工作的一段内存区域。

用来存放局部变量和函数返回地址。

源程序中堆栈段用于在调用子程序时保存返回地址;进入子程序后保留通用寄存器的值,子程序执行完毕返回时恢复寄存器的值,并分别将返回地址恢复到指令指针寄存器中。

3.采用哪些语句实现多重循环?循环次数如何设定?实现多重循环可采用循环语句嵌套使用实现,实现循环功能的语句有:1.采用CX计数:LOOP(CX不为0循环)、LOOPE(结果为0循环)、LOOPNE(不为0循环)、JCXZ(CX的值为0转移),每次循环一次CX自减1直到为0跳出循环。

川大微机上机实验报告(冒泡排序法)

川大微机上机实验报告(冒泡排序法)

上机目的: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遍。

完成第一遍排序后,最大数沉底,已经到达它应占据的位置,不需要参加下一遍的排序。

思考如何输入任意五个数,五个数可以有一位数,二位数,三位数,四位数,五位数,混合输入比较大小;2、对这组数用冒泡法进行排序,并输出原始数据及排序后数据,两两数据之间用空格分隔;3、利用DEBUG调试工具,用D0命令,查看排序前后,内存数据的变化,以及会用调试命令查看程序运算中寄存器中的值;4、去掉最大和最小的两个值,求出其余值的平均值,并输出最大值,最小值和平均值;5、用压栈PUSH和出栈POP指令“先进后出”的特点,设计算法将平均值按位逐个输出(即输出263);6、用移位指令将平均值以二进制串的形式输出。

7、设计程序要有模块化的思想,用子程序实现不同的功能;8、所有数据输出前要用字符串的输出指令,进行输出提示(如:zui dazhi shi : 300等),所有数据结果能清晰地显示在电脑屏幕上。

程序流程图如下:程序清单:DATAS SEGMENTSHURU DB 'QING SHU RU 5 GE SHU JU',13,10,'$'SHU1 DB 4,?,3 DUP(?)SHU2 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 ENDSCODES 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,0PUSH CX;外循环次数入栈PX: 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,9INT 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 21HADD SI,2POP 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,10MOV AH,2INT 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,30HPUSH 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码MOV AVER,ALMOV AL,AHXOR AH,AHDIV [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,9INT 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 21HCODES ENDSEND START运行结果:心得体会:本次实验编程比较复杂,在编这个程序之前自己先将前面三个练习编了一下,然后参考了书上的一个冒泡排序法的程序,之后才开始动手编该程序。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

template <class T> T Stack<T>::Pop(){
if(IsEmpty()) cout<<"OutOfBounds"<<endl;
T x=stack[top]; top--; return x; } #include <iostream> #include <time.h> #include <stdlib.h>
}
FindPath(maze,row,col); return 0; } //寻找一个从[1,1]到[m,m]的路径 void FindPath(int **maze,int row,int col){ Stack<Position> path; Position offset[4]; offset[0].row = 0; offset[0].col = 1; //向右 offset[1].row = 1; offset[1].col = 0; //向下 offset[2].row = 0; offset[2].col =-1; //向左 offset[3].row =-1; offset[3].col = 0; //向上 Position here; here.row=1; here.col=1; maze [1][1] = 1; // 阻止返回入口 int option = 0; int LastOption = 3; //寻找一条路径 while (here.row != row || here.col != col) { // 不是出口 //寻找一个相邻位置来移动
if (path.IsEmpty()) cout<<"There is no path!"<<endl;
Position next; next=path.Pop(); //计算 option 的值 if (next.row == here.row)
option = 2 + next.col - here.col; else
#include "Stack.h"
#include "Position.h"
using namespace std;
void FindPath(int**,int,int);
int main(){ //生成随机数
srand(time(NULL));
int row,col;
int i=0,j=0;
//初始化数组,给迷宫加围墙 1
for( j = 0 ; j < col+2 ; j ++ )
maze[i][j]=1; for( i = 1 ; i < row+1 ; i ++ )
//将迷宫载入数组 maze 中
for( j = 1 ; j < col+1 ; j ++ ) maze[i][j]=rand()%2; //产生 0 或 1
int **maze; cout<<"请输入迷宫的大小:"<<endl;
cin>>row>>col;
maze=new int*[row+1];
for(i = 0 ; i < row+2 ; i ++ )
maze[i] = new int[col+2] ; for( i = 0 ; i < row+2 ; i ++ )
bool IsEmpty() const{return top==-1;}
bool IsFull() const{return top==MaxTop;}
T Top() const;
void Push(const T& x);
T Pop();
private:
int top; //当前栈顶
int MaxTop; //栈顶最大值
T *stack;
//空指针
};
#endif /* STACK_ */
template <class T>
Stack<T>::Stack(int MaxSize){
MaxTop=MaxSize-1;
stack=new T[MaxSize];
top=-1; }
//栈顶=栈底
template <class T> T Stack<T>::Top() const{
if(IsEmpty()) cout<<"OutOfBounds"<<endl;
else return stack[top];
}
template <class T> void Stack<T>::Push(const T& x){
if(IsFull()) cout<<"NoMem"<<endl;
top++; stack[top]=x; }
class Position
{
public: int row; //行坐标 int col; //列坐标
ቤተ መጻሕፍቲ ባይዱ
};
#ifndef STACK_
#define STACK_
#include <iostream.h> //自定义的堆栈
template <class T>
class Stack{
public:
Stack(int MaxSize=15);
maze[1][1]=0;
maze[row][col]=0;
cout<<"The maze is:"<<endl;
for( i = 1 ; i < row+1 ; i ++ ){
for( j = 1 ; j < col+1 ; j ++ ){
cout<<maze[i][j]<<" ";
}
cout<<endl;
int r, c; while (option <= LastOption) {
r = here.row + offset[option].row ; c = here.col + offset[option].col ; if (maze[r][c] == 0)
break; option++; //下一个选择 } // 找到一个相邻位置了吗?
if (option <= LastOption) { //移动到 maze[r][c] path.Push(here); //将此位置放到堆栈中 here.row = r; here.col = c; maze [r][c] = 1; //设置障碍物以阻止再次访问 option=0;
} else { //没有可用的相邻位置,回溯
option = 3 + next.row - here.row; here = next; } } here.row=row; here.col=col; path.Push(here); cout<<"由出口回朔到入口打印路径:"<<endl; while(!path.IsEmpty()){ Position a=path.Pop(); cout<<"("<<a.row<<","<<a.col<<") "; } cout<<endl; }
相关文档
最新文档