冒泡排序（java/c）

最新推荐文章于 2022-07-24 22:22:06 发布

卢瑟福四世IV

最新推荐文章于 2022-07-24 22:22:06 发布

阅读量282

点赞数 1

分类专栏：笔记文章标签：算法排序算法数据结构 java c语言

本文链接：https://blog.csdn.net/qq_44722109/article/details/125857678

版权

笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

冒泡排序：又称相邻排序法，是一种交换类排序方法，通过对相邻两个数据元素进行交换，逐步将待排序序列变成有序序列。

算法思想

反复扫描待排序序列，在排序过程中顺次比较相邻两个元素的大小，若逆序直接交换。

例如对于 3 1 2 10 5 7 8 9 4 6，要将序列进行升序排序，从第一个元素开始进行比较，相邻元素前者大于后者就交换。

下面为对该序列的一轮排序过程：

初始序列 3 1 2 10 5 7 8 9 4 6
1 3 2 10 5 7 8 9 4 6
1 2 3 10 5 7 8 9 4 6
1 2 3 10 5 7 8 9 4 6
1 2 3 5 10 7 8 9 4 6
1 2 3 5 7 10 8 9 4 6
1 2 3 5 7 8 10 9 4 6
1 2 3 5 7 8 9 10 4 6
1 2 3 5 7 8 9 4 10 6
第一轮结束：1 2 3 5 7 8 9 4 6 10

在第一轮结束后，将最大的数字10“沉”在了最下面，第二轮同理

第1轮排序后的结果：1 2 3 5 7 8 9 4 6 10
第2轮排序后的结果：1 2 3 5 7 8 4 6 9 10
第3轮排序后的结果：1 2 3 5 7 4 6 8 9 10
第4轮排序后的结果：1 2 3 5 4 6 7 8 9 10
第5轮排序后的结果：1 2 3 4 5 6 7 8 9 10

核心代码部分：

void bubbleSort(int a[],int n)
{
	int i,j,k,temp;
	for(i=0;i<n-1;i++)//冒泡排序最多进行n-1次 
	{
		
		for(j=0;j<n-1-i;j++)
		{
			if(a[j]>a[j+1])//相邻两个元素前者比后者大时就进行交换
			   {
			   	temp=a[j];//交换一次移动三次
			   	a[j]=a[j+1];
			   	a[j+1]=temp;
			   	
			   }
		}

	 } 
}

对代码进行优化，引入一个flag变量，当一轮排序之后元素顺序没有发生变化时，则认为元素已经处于升序序列，认定排序结束，直接跳出。

优化后代码：

void bubbleSort(int a[],int n)
{
	int i,j,k,temp;
	for(i=0;i<n-1;i++)//冒泡排序最多进行n-1次 
	{
		int flag=0;
		for(j=0;j<n-1-i;j++)
		{
			if(a[j]>a[j+1])//相邻两个元素前者比后者大时就进行交换
			   {
			   	temp=a[j];
			   	a[j]=a[j+1];
			   	a[j+1]=temp;
			   	flag=1;
			   }
		}
		if(flag==0)//当某一趟排序没有元素位置发生变化时则表示已经排好序直接退出 
		break;	
		printf("第%d轮排序后的结果：",i+1);
		for(k=0;k<n;k++)
		printf("%-4d",a[k]);
		printf("\n"); 
	 } 
}

冒泡排序最多进行n-1轮排序，在全部逆序（最坏情况）的情况下，此时第i趟冒泡排序需要n-i次比较，3(n-i)次移动，经过n-1次排序后，总的比较次数为

$\sum_{i=1}^{n-1}n-i=n(n-1)/2$

每次交换需要移动三次元素，总的移动次数为3n(n-1)/2次，因此该算法的时间复杂度为O(n^2)，在交换时只需要一个辅助空间，因此空间辅助度为O(1),同时冒泡排序也是一种稳定排序算法。

C语言版

#include<stdio.h>
void bubbleSort(int a[],int n)
{
	int i,j,k,temp;
	for(i=0;i<n-1;i++)//冒泡排序最多进行n-1次 
	{
		int flag=0;
		for(j=0;j<n-1-i;j++)
		{
			if(a[j]>a[j+1])//相邻两个元素前者比后者大时就进行交换
			   {
			   	temp=a[j];
			   	a[j]=a[j+1];
			   	a[j+1]=temp;
			   	flag=1;
			   }
		}
		if(flag==0)//当某一趟排序没有元素位置发生变化时则表示已经排好序直接退出 
		break;	
		printf("第%d轮排序后的结果：",i+1);
		for(k=0;k<n;k++)
		printf("%-4d",a[k]);
		printf("\n"); 
	 } 
}
int main(){
	int a[10];
	printf("please enter 10 numbers:\n");
	for(int i=0;i<10;i++)
	   scanf("%d",&a[i]);
	printf("the array before sort:\n");
	for(int i=0;i<10;i++)
	printf("%-4d",a[i]);
	printf("\n");
	bubbleSort(a,10);
	printf("the array after sort:\n");
	for(int i=0;i<10;i++)
	printf("%-4d",a[i]);
	return 0;	   
}

运行结果：

java版

import java.util.Scanner;
public class bubbleSort {
    public static void main(String[]args){
        Scanner input=new Scanner(System.in);
        int[]a=new int[10];
        System.out.println("please enter 10 numbers");
        for(int i=0;i<a.length;i++)
            a[i]=input.nextInt();
        System.out.println("the array before sort:");
        print(a);
        System.out.println();
        sort(a);
        System.out.println("the array after sort:");
        print(a);
    }
    public static void print(int []a){
        for(int i=0;i<a.length;i++)
            System.out.printf("%-4d",a[i]);
    }
    public static void sort(int []a){
        int i,j,k,temp;
        for(i=0;i<a.length-1;i++)//冒泡排序最多进行n-1次
        {
            int flag=0;
            for(j=0;j<a.length-1-i;j++)
            {
                if(a[j]>a[j+1])
                {
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    flag=1;
                }
            }
            if(flag==0)//当某一趟排序没有元素位置发生变化时则表示已经排好序直接退出
                break;
            System.out.println("round of sorting:"+(i+1));
            for(k=0;k<a.length;k++)
                System.out.printf("%-4d",a[k]);
            System.out.println();
        }
    }
}

运行结果：