下载文档原格式
快速排序算法c语言实验报告冒泡法和选择法排序C程序实验报告实验六：冒泡法排序物理学416班赵增月F12 2011412194日期：2013年10月31日一·实验目的 1.熟练掌握程序编写步骤；2.学习使用冒泡法和选择法排序；3.熟练掌握数组的定义和输入输出方法。
二·实验器材1.电子计算机；2.VC6.0三·实验内容与流程1.流程图（1）冒泡法(2)选择法 2.输入程序如下：（1）冒泡法#includestdio.h void main() { int a[10]; int i,j,t; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]); printf(\n); for(j=0;j9;j++)for(i=0;i9-j;i++) if(a[i]a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } printf(排序后如下：\n); for(i=0;i10;i++) printf(%d,a[i]); printf(\n); }（2）选择法#includestdio.h void main() { int a[10]; int i,j,t,k; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]);printf(\n); for(i=0;i9;i++) {k=i;for(j=i+1;j10;j++) if (a[k]a[j])k=j;t=a[i];a[i]=a[k];a[k]=t; }printf(排序后如下：\n); for(i=0;i10;i++)printf(%d,a[i]); printf(\n); }四．输出结果（1冒泡法）请输入10个数字：135****2468排序后如下：12345678910 （2）选择法输出结果请输入10个数字：135****6810排序后如下：12345678910五．实验反思与总结1.冒泡法和选择法是一种数组排序的方法，包含两层循环，写循环时，要注意循环变量的变化范围。
c语言冒泡函数冒泡函数是一种常用的排序算法，它的原理是通过多次比较相邻的元素并交换位置，将最大（或最小）的元素逐渐“浮”到数组的末尾，从而实现整个数组的排序。
冒泡函数的思想简单直观，容易理解和实现，但在处理大规模数据时效率较低。
冒泡函数的实现是基于两层嵌套循环的。
外层循环控制排序的轮数，每一轮将确定一个元素的最终位置；内层循环用于比较相邻的两个元素并进行交换。
具体实现如下：```cvoid 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]) {// 交换arr[j]和arr[j+1]int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```以上是冒泡函数的实现代码。
首先，我们通过传入一个整型数组和数组长度的参数来对数组进行排序。
外层循环从第一个元素开始，依次遍历到倒数第二个元素，内层循环从第一个元素开始，依次比较相邻的两个元素，并进行交换。
如果前一个元素大于后一个元素，则进行交换。
通过这样的比较和交换，每一轮都能将最大的元素“浮”到数组的末尾。
冒泡函数的时间复杂度为O(n^2)，其中n为数组的长度。
这是因为冒泡函数需要进行n-1轮比较和交换，每一轮比较的次数为n-i-1。
虽然冒泡函数的时间复杂度较高，但对于小规模的数据排序仍然是一种简单有效的方法。
除了冒泡函数的基本实现外，还可以对其进行一些改进，以提高排序的效率。
例如，可以设置一个标志位flag来记录每一轮是否进行了交换操作，如果某一轮没有进行交换，说明数组已经有序，可以提前结束排序。
这样可以减少不必要的比较和交换，提高算法的效率。
c语言对double数组排序C语言对double数组进行排序有多种方法，包括冒泡排序、选择排序、插入排序、快速排序等。
本文将介绍其中几种常见的排序方法。
首先是冒泡排序，它是一种简单直观的排序算法。
冒泡排序的基本思想是通过相邻元素的比较和交换来将数组中较大的元素逐步“冒泡”到末尾。
下面是使用C语言实现的冒泡排序算法：```cvoid bubble_sort(double 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]) {double temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```其次是选择排序，它是一种简单且不稳定的排序算法。
选择排序的基本思想是每次从未排序的部分选择最小（或最大）的元素放到已排序部分的末尾。
下面是使用C语言实现的选择排序算法：```cvoid selection_sort(double arr[], int n) {int min_idx;for (int i = 0; i < n-1; ++i) {min_idx = i;for (int j = i+1; j < n; ++j) {if (arr[j] < arr[min_idx]) {min_idx = j;}}double temp = arr[i];arr[i] = arr[min_idx];arr[min_idx] = temp;}}```接下来是插入排序，它是一种稳定的排序算法。
插入排序的基本思想是将数组分成已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的正确位置。
下面是使用C语言实现的插入排序算法：```cvoid insertion_sort(double arr[], int n) {int i, j;double key;for (i = 1; i < n; ++i) {key = arr[i];j = i - 1;while (j >= 0 && arr[j] > key) {arr[j+1] = arr[j];--j;}arr[j+1] = key;}}```最后是快速排序，它是一种常用且高效的排序算法。
使⽤C语⾔实现12种排序⽅法⽬录1.冒泡排序2.插⼊排序3.折半插⼊排序4.希尔排序5.选择排序6.鸡尾酒排序7.堆排序8.快速排序9.归并排序10.计数排序11.桶排序12.基数排序1.冒泡排序思路：⽐较相邻的两个数字，如果前⼀个数字⼤，那么就交换两个数字，直到有序。
时间复杂度O(n^2)，稳定性：这是⼀种稳定的算法。
代码实现：void bubble_sort(int arr[],size_t len){size_t i,j;for(i=0;i<len;i++){bool hasSwap = false; //优化，判断数组是否已经有序，如果有序可以提前退出循环for(j=1;j<len-i;j++){ //这⾥j<len-i是因为最后⾯的肯定都是最⼤的，不需要多进⾏⽐较if(arr[j-1]>arr[j]){ //如果前⼀个⽐后⼀个⼤swap(&arr[j-1],&arr[j]); //交换两个数据hasSwap = true;}}if(!hasSwap){break;}}}2.插⼊排序思路：把⼀个数字插⼊⼀个有序的序列中，使之仍然保持有序，如对于需要我们进⾏排序的数组，我们可以使它的前i个数字有序，然后再插⼊i+1个数字，插⼊到合适的位置使之仍然保持有序，直到所有的数字有序。
时间复杂度：O(n^2) 稳定性：稳定的算法代码实现：void insert_sort(int arr[],int len){int i,j;for(i=1;i<len;i++){int key = arr[i]; //记录当前需要插⼊的数据for(j= i-1;i>=0&&arr[j]>key;j--){ //找到插⼊的位置arr[j+1] = arr[j]; //把需要插⼊的元素后⾯的元素往后移}arr[j+1] = key; //插⼊该元素}}3.折半插⼊排序思路：本质上是插⼊排序，但是通过半分查找法找到插⼊的位置，让效率稍微快⼀点。
双向冒泡排序算法（C语言）1. 算法原理双向冒泡排序算法是冒泡排序算法的优化版本，它在每一轮的比较中同时从左往右和从右往左进行排序，以提高性能。
该算法的核心思想是通过交替地向左和向右进行冒泡来实现排序。
具体算法步骤如下：1.初始化两个指针left和right，分别指向排序序列的第一个和最后一个元素。
2.从left向right遍历，在遍历过程中不断比较相邻的两个元素，并将较大（或较小）的元素向右（或向左）冒泡，直到right指针达到left位置。
3.更新left指针的位置，即left = left + 1。
4.从right向left遍历，在遍历过程中不断比较相邻的两个元素，并交换位置，将较小（或较大）的元素向左（或向右）冒泡，直到left指针达到right位置。
5.更新right指针的位置，即right = right - 1。
6.重复步骤2~5，直到排序序列中的所有元素都排序完成。
2. 算法实现（C语言）下面是使用C语言实现双向冒泡排序算法的示例代码：#include <stdio.h>void bidirectional_bubble_sort(int arr[], int n) {int left = 0;int right = n - 1;int i, j;while (left < right) {for (i = left; i < right; i++) {if (arr[i] > arr[i + 1]) {int temp = arr[i];arr[i] = arr[i + 1];arr[i + 1] = temp;}}right--;for (j = right; j > left; j--) {if (arr[j] < arr[j - 1]) {int temp = arr[j];arr[j] = arr[j - 1];arr[j - 1] = temp;}}left++;}}int main() {int arr[] = {4, 2, 8, 5, 1, 9, 3, 7, 6};int n = sizeof(arr) / sizeof(arr[0]);printf("Before sorting:\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}bidirectional_bubble_sort(arr, n);printf("\nAfter sorting:\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}return 0;}3. 算法分析双向冒泡排序算法的时间复杂度和冒泡排序算法相同，都为O(n^2)，其中n为排序序列的长度。
c语言中冒泡法冒泡法是一种简单直观的排序算法，常被用于教学中。
它的实现过程简单易懂，算法效率较低，仅适合小规模数据排序。
下面我们就来深入了解一下什么是冒泡法，以及它的运作原理。
冒泡法排序可以用一个很形象的比喻来描述，在水中有很多气泡，气泡的大小不一，我需要从小到大排序将气泡排列好。
排列的方式就是在一次遍历中，将相邻的两个气泡进行大小的比较，将大的往后移动一位，一直遍历到最后，这样第一大的气泡就会“冒泡”到最后一位。
接着，再次遍历，只不过这一次不需要将最后一位参与比较，依次类推，最终完成排序。
在C语言中实现冒泡排序算法，需要先用数组来存储需要排序的数值，然后通过两重循环来实现。
外层循环控制遍历次数，内层循环进行相邻数值的比较并交换位置。
代码实现类似于下面：```cvoid bubble_sort(int arr[], int len){int i, j, temp;for (i = 0; i < len - 1; i++){for (j = 0; j < len - 1 - i; j++){if (arr[j] > arr[j + 1]){temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```冒泡排序算法的时间复杂度为O(n^2)，因此效率较低。
但是，它的实现过程简单，易于理解，非常适合初学者学习排序算法。
同时，经过改进，冒泡排序算法也被广泛应用于其他领域，例如图像处理中的边缘检测。
总之，冒泡法虽然简单，但可以锻炼我们对算法的理解，增加对编程的把握。
具体算法实现可以根据实际情况进行不同的优化，达到更高的效率和效果。
c语言中冒泡法
冒泡排序是一种简单的排序算法，它的基本思想是将待排序的数据元素按照大小关系通过两两比较不断交换位置，直到所有的数据都排列完成为止。
C语言中，我们可以通过两重循环来实现冒泡排序。
具体实现过程如下：
1. 定义一个待排序的数组，例如 int arr[10] = {5, 2, 8, 3, 9, 1, 6, 0, 7, 4}；
2. 外层循环从数组的第一个元素开始遍历到倒数第二个元素，即 for(int i=0; i<9; i++)；
3. 内层循环从外层循环遍历到的元素的下一个元素开始遍历到数组的最后一个元素，即 for(int j=i+1; j<10; j++)；
4. 在内层循环中进行两两比较，如果前一个元素大于后一个元素，则交换它们的位置，即 if(arr[i]>arr[j]){ int temp=arr[i]; arr[i]=arr[j]; arr[j]=temp;}；
5. 直到内层循环遍历结束，外层循环继续向后遍历；
6. 直到外层循环遍历结束，排序完成，输出结果即可。
这就是冒泡排序的具体实现过程，通过反复比较和交换来完成排序操作。
冒泡排序实现代码以及图⽰详解⼀、冒泡排序冒泡排序（Bubble Sort），是⼀种计算机科学领域的较简单的排序算法。
它重复地⾛访过要排序的元素列，依次⽐较两个相邻的元素，如果顺序（如从⼤到⼩、⾸字母从Z到A）错误就把他们交换过来。
⾛访元素的⼯作是重复地进⾏直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中⼆氧化碳的⽓泡最终会上浮到顶端⼀样，故名“冒泡排序”。
⼆、算法实现原理1. ⽐较相邻的元素。
如果第⼀个⽐第⼆个⼤，就交换它们两个；2. 对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对，在这⼀点，最后的元素理应会是最⼤的数；3. 针对所有的元素重复以上的步骤，除了最后⼀个；4. 持续每次对越来越少的元素重复上⾯的步骤，直到没有任何⼀对数需要⽐较；三、复杂度分析若⽂件的初始状态是正序的，⼀趟扫描即可完成排序。
所需的关键字⽐较次数C和记录移动次数M均达到最⼩值：所以，冒泡排序最好的时间复杂度为：O（n）若初始⽂件是反序的，需要进⾏n-1趟排序。
每趟排序要进⾏n-i次关键字的⽐较(1≤i≤n-1)，且每次⽐较都必须移动记录三次来达到交换记录位置。
在这种情况下，⽐较和移动次数均达到最⼤值：冒泡排序的最坏时间复杂度为O（n^2）所以，冒泡排序总的时间复杂度为O（n^2）四、稳定性分析冒泡排序就是把⼩的元素往前调或者把⼤的元素往后调。
⽐较是相邻的两个元素⽐较，交换也发⽣在这两个元素之间。
所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前⾯的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是⼀种稳定排序算法。
五、算法图⽰分析图⽰过程动图展⽰六、JAVA代码实现1//⽐较函数参考2static boolean less(Comparable v, Comparable w) {3return pareTo(w) < 0;4 }5//交换函数6static void exchange(Object[] a, int i, int j) {7 Object swap = a[i];8 a[i] = a[j];9 a[j] = swap;10 }1112public void bubblesort(Comparable[]a){13int n = a.length;14for(int i=0;i<n-1;i++){//记录已经排序的元素的数量15for(int j=0;j<n-i-1;j++){//开始排序，除去了已经排序了的16if(a[j]<a[j+1]){ //降序排列17 swap(a,j,j+1);18 }19 }20 }21 }七、算法优化针对问题：数据的顺序排好之后，冒泡算法仍然会继续进⾏下⼀轮的⽐较，直到arr.length-1次，后⾯的⽐较没有意义的。
#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环，每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。
