一.冒泡排序

主要思想:

反复交换相邻的元素,使较大的元素 逐渐冒泡到数组的末尾,从而实现排序的效果

实现过程:

1.遍历待排序数组,比较相邻的元素,如果前面的元素比后面的元素大,

     就交换这两个元素的位置

2.重复上述操作,直至不再需要交换

3.返回排序后的结果

演示:(64    34    25   12    22    11     90)

第一躺:

64    34    25   12    22    11     90

34    64    25   12    22    11     90       (64>34  交换)   

34    25    64   12    22    11     90       ( 64>25  交换)

34    25    12   64    22    11     90       (64>12    交换)

34    25    12   22    64    11     90       (64>22    交换)

34    25    12   22    11    64     90       (64>11    交换)

34    25    12   22    11    64     90       (64<90   不交换)

第二趟:

34    25    12   22    11    64     90 

25    34    12   22    11    64     90  (34>25 交换)

25    12    34   22    11    64     90  (34>12 交换)

25    12    22   34    11    64     90  (34>22 交换)

25    12    22   11    34    64     90  (34>11 交换)

25    12   22    11     34    64     90 (34<64 不交换)

25    12   22    11     34    64     90  (64<90 不交换)

第三趟:

25    12   22    11     34    64     90 

12    25   22    11     34    64     90  (25>12 交换)

12    22   25    11     34    64     90 (25>22 交换)

12    22   11    25     34    64     90 (25>11 交换)

12    22   11    25     34    64     90 (25<34 不交换)

12    22   11    25     34    64     90(34<64 不交换)

12    22   11    25     34    64     90 (64<90 不交换)

第三趟:

12    22   11    25     34    64     90 

12    22   11    25     34    64     90 (12<22 不交换)

12   11    22    25     34    64     90 (22>11 交换)

12    11   22    25     34    64     90   (22<25 不交换)

12    11   22    25     34    64     90 (25<34 不交换)

12    11   22    25     34    64     90 (34<64 不交换)

12    11   22    25     34    64     90 (64<90 不交换)

第四趟:

12    11   22    25     34    64     90

11    12   22    25     34    64     90

总结:

冒泡排序的时间复杂度为O(n^2),是一种稳定的排序方法,在实际应用中可能效率低。

二. C语言版
#include<stdio.h> #include<Windows.h> void bubble_sort(int arr[] ,int n){ int
i ,j,temp; for(i=0;i<n-1;i++){ for(j=0;j<n-1;j++){ if(arr[j] > arr[j+1]){
temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } int main(){ int arr[]
={64,34,25,12,22,11,90}; int n=sizeof(arr)/sizeof(arr[0]); bubble_sort(arr,n);
printf("Sorted array:\n"); for(int i=0;i<n;i++){ printf("%d ",arr[i]); }
system("pause"); return 0; }
代码解析:

#include<stdio.h>
#include<Windows.h>
void bubble_sort(int arr[] ,int n){
//冒泡排序算法,参数为整数数组和数组大小
    int i ,j,temp;
//定义比较用的两个指针i和j
    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;
            }
        }
    }
}
    int main(){
        int arr[] ={64,34,25,12,22,11,90};
//声明未排序的整数数组
        int n=sizeof(arr)/sizeof(arr[0]);
//通过数组长度计算元素数量
        bubble_sort(arr,n);
//调用冒泡排序算法
        printf("Sorted array:\n");
        for(int i=0;i<n;i++){
//循环遍历排序后的数组并打印出来
            printf("%d ",arr[i]);
        }
            system("pause"); 
        return 0;
        
        
    }

调试:

三.Java版
package BubbleSort; public class BubbleSort { public static void main(String[]
args) { int [] arr={64,34,25,12,22,11,90}; bubbleSort(arr); for(int num:arr){
System.out.println(num+""); } } private static void bubbleSort(int[] arr) { int
temp; for(int i=0;i<arr.length-1;i++){ for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){ temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } }
调试:

 

 

技术
今日推荐
PPT
阅读数 84
下载桌面版
GitHub
百度网盘(提取码:draw)
Gitee
云服务器优惠
阿里云优惠券
腾讯云优惠券
华为云优惠券
站点信息
问题反馈
邮箱:ixiaoyang8@qq.com
QQ群:766591547
关注微信