微机原理实验报告冒泡排序

一、实验目的和要求理解和掌握冒泡排序技术，使用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语言编写程序，提高了我的编程能力，受益匪浅。

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

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

冒泡法排序实验报告一、实验任务实现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;}四、实验结果。

一、实验目的1. 理解冒泡排序算法的基本原理和实现过程。

2. 分析冒泡排序算法的时间复杂度和空间复杂度。

3. 通过实验验证冒泡排序算法在不同数据规模下的性能表现。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发环境：PyCharm三、实验内容1. 冒泡排序算法的实现2. 冒泡排序算法的性能测试3. 结果分析四、实验步骤1. 实现冒泡排序算法```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]return arr```2. 生成测试数据```pythonimport randomdef generate_data(n):return [random.randint(0, 10000) for _ in range(n)]```3. 测试冒泡排序算法性能```pythondef test_bubble_sort():data_sizes = [100, 1000, 10000, 100000]for size in data_sizes:data = generate_data(size)sorted_data = bubble_sort(data.copy())assert sorted_data == sorted(data), "排序结果错误"print(f"数据规模：{size}, 排序耗时：{time.time() - start_time:.4f}秒")start_time = time.time()test_bubble_sort()print(f"实验总耗时：{time.time() - start_time:.4f}秒")```五、结果分析1. 冒泡排序算法的时间复杂度分析冒泡排序算法的时间复杂度主要取决于两层循环的执行次数。

第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. 理解排序算法的基本原理。

2. 掌握几种常见的排序算法（冒泡排序、选择排序、插入排序、快速排序等）。

3. 分析不同排序算法的时间复杂度和空间复杂度。

4. 通过实验验证排序算法的性能。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发环境：PyCharm三、实验内容本次实验主要涉及以下几种排序算法：1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序四、实验步骤1. 定义排序函数首先，我们需要定义一个通用的排序函数，用于调用不同的排序算法。

```pythondef sort(arr, algorithm):if algorithm == 'bubble':bubble_sort(arr)elif algorithm == 'selection':selection_sort(arr)elif algorithm == 'insertion':insertion_sort(arr)elif algorithm == 'quick':quick_sort(arr)else:raise ValueError("Invalid sorting algorithm") ```2. 实现排序算法下面分别实现冒泡排序、选择排序、插入排序和快速排序。

```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j] def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]def insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = keydef quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[len(arr) // 2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right) ```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行提示的错误。

实验报告实验名称_ _冒泡排序实验_课程名称____ __ __微机原理_____________院系部:控计学院专业班级：信安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四、调试结果及调试分析五、结论与心得我们不仅要学习书本上的知识，更要知识与实践相结合，多动手发现问题解决问题，学会举一反三、融会贯通。

一、实验目的1. 理解冒泡排序算法的基本原理；2. 掌握冒泡排序算法的实现方法；3. 分析冒泡排序算法的时间复杂度；4. 通过实验验证冒泡排序算法的效率。

二、实验原理冒泡排序是一种简单的排序算法，它通过重复遍历待排序的数列，比较每对相邻的项，并在顺序错误时交换它们的位置，直到没有需要交换的项为止。

由于排序过程中小数逐渐浮到前面，大数逐渐沉到后面，故得名冒泡排序。

冒泡排序的基本思想是：比较相邻的两个元素，如果它们的顺序错误（即前一个比后一个大），则交换它们的位置。

这样，每一轮遍历后，最大的元素就会被“冒泡”到数组的末尾。

重复此过程，直到整个数组排序完成。

三、实验步骤1. 准备实验材料：一组待排序的整数序列；2. 实现冒泡排序算法，包括以下步骤：a. 初始化一个布尔变量flag，用于标记是否发生了交换；b. 遍历数组，比较相邻的两个元素，如果顺序错误则交换它们的位置；c. 如果在某一轮遍历中没有发生交换，说明数组已经排序完成，退出循环；d. 重复步骤b和c，直到数组排序完成；3. 对排序结果进行验证，确保数组已正确排序；4. 记录冒泡排序算法的执行时间；5. 分析冒泡排序算法的时间复杂度。

四、实验结果与分析1. 实验数据（1）待排序数组：[5, 3, 8, 6, 2, 7, 4, 1]（2）排序前数组：[5, 3, 8, 6, 2, 7, 4, 1]（3）排序后数组：[1, 2, 3, 4, 5, 6, 7, 8]2. 实验结果冒泡排序算法对上述数组进行排序，经过8轮遍历后，数组已正确排序。

3. 实验分析（1）冒泡排序的时间复杂度分析冒泡排序的时间复杂度为O(n^2)，其中n是待排序数组的长度。

原因如下：- 在最坏的情况下（即数组完全逆序），冒泡排序需要进行n-1轮遍历，每轮遍历需要比较n-1次，因此总比较次数为(n-1)+(n-2)+...+1，即(n-1)n/2，即O(n^2)。

- 在最好的情况下（即数组已经排序），冒泡排序在第一轮遍历后即可发现没有发生交换，此时只需进行一轮遍历，比较次数为n-1，即O(n)。