精华内容
下载资源
问答
  • 冒泡排序法
    2022-05-15 19:28:51

    冒泡排序算法的运作如下:

    比较相邻的元素。如果第一个比第二个大,就交换他们两个。

    对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

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

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

    相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

    pubilc void MaoPao(){
        int[] nums = {34,4,56,17,90,65};
        //外循环控制轮数
        for(int i=0;i<nums.length-1;i++){
            for(int j =0;j<nums.length-1-i;j++){
                if(nums[j]>nums[j+1]){
                    nums[j] = nums[j]+nums[j+1];
                    nums[j+1] = nums[j]-nums[j+1];
                    nums[j] = nums[j]-nums[j+1];
                }
            }
        }
        //输出结果
        for(int n :nums){
            System.out.println(n);
        }
    }

    更多相关内容
  • 汇编语言编写的冒泡排序程序代码,从小到大排序,并以十进制字符串的形式输出排序结果。
  • 主要为大家详细介绍了C++实现双向冒泡排序算法,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • /*@冒泡排序算法 */ $array=array(5,45,22,11,32,28,35,56,17,21,92); $len=count($array);//计算数组长度 for($i=0;$i<$len-1;$i++){//需要比较$len-1轮,每一轮需要比较$len-1次 for($j=0;$j<$len-1;$j++){...
  • 冒泡排序算法

    万次阅读 2021-01-31 11:46:05
    一、冒泡排序算法基本思想 将第一个元素和第二个元素进行比较,若为逆序则将两个元素交换,然后比较第二个元素和第三个元素。依次类推,直至第 n-1个元素和第 n个元素进行比较为止。上述过程称为第一趟冒泡排序,其...

    一、冒泡排序算法基本思想

    将第一个元素和第二个元素进行比较,若为逆序则将两个元素交换,然后比较第二个元素和第三个元素。依次类推,直至第 n-1个元素和第 n个元素进行比较为止。上述过程称为第一趟冒泡排序,其结果使最大值元素被放置在最后一个位置(第 n个位置)。然后进行第二趟冒泡排序,对前 n-1个元素进行同样操作,其结果是使第二大元素被放置在倒数第二个位置上(第 n-1个位置)。

    二、冒泡排序图解

    黄色表示已排序部分,蓝色表示未排序部分。
    在这里插入图片描述
    三、代码实现

    package Sort;
    
    import java.util.Arrays;
    
    public class BubbleSort {
    	public static void bubblesort(int[] arr) {
    		for(int i=0;i<arr.length;i++) {
    			for(int j=i+1;j<arr.length;j++) {
    				if(arr[i]>arr[j]) {//若前一个元素比后一个元素大,则借助临时变量temp交换(此排序为升序排序,若为降序排序则为arr[i]<arr[j])
    					int temp=arr[i];
    					arr[i]=arr[j];
    					arr[j]=temp;
    				}
    			}
    		}
    	}
    	public static void main(String[] args) {
    		int[] arr= {3, 9, -1, 10, 20};
    		System.out.println("冒泡排序前:");
    		System.out.println(Arrays.toString(arr));
    		bubblesort(arr);
    		System.out.println("冒泡排序后:");
    		System.out.println(Arrays.toString(arr));
    	}
    }
    
    

    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    从上图中可以看出:冒泡排序一共进行 arr.length-1次大循环,且每趟冒泡排序的次数在减少,因为每次确定一个元素在最后位置。

    四、代码改进

    若数组本身有序,则不需要进行每次循环判断,增加一个标志位标识每次是否进行交换即可。

    public static void bubblesort(int[] arr) {
    		boolean flag=false;//标志位,标志是否进行交换
    		for(int i=0;i<arr.length;i++) {
    			for(int j=i+1;j<arr.length;j++) {
    				if(arr[i]>arr[j]) {//若前一个元素比后一个元素大,则借助临时变量temp交换
    					flag=true;//若交换则将flag变为true
    					int temp=arr[i];
    					arr[i]=arr[j];
    					arr[j]=temp;
    				}
    			}
    		if(!flag) {//没有交换直接break
    			break;
    		}else {
    			flag=false;//若有交换进行下次判断
    		}
    		}
    	}
    

    五、冒泡排序算法性能测试

    package Sort;
    
    import java.text.SimpleDateFormat;
    import java.util.Arrays;
    import java.util.Date;
    public class BubbleSort {
    	public static void bubblesort(int[] arr) {
    		boolean flag=false;//标志位,标志是否进行交换
    		for(int i=0;i<arr.length;i++) {
    			for(int j=i+1;j<arr.length;j++) {
    				if(arr[i]>arr[j]) {//若前一个元素比后一个元素大,则借助临时变量temp交换
    					flag=true;//若交换则将flag变为true
    					int temp=arr[i];
    					arr[i]=arr[j];
    					arr[j]=temp;
    				}
    			}
    		if(!flag) {//没有交换直接break
    			break;
    		}else {
    			flag=false;//若有交换进行下次判断
    		}
    		}
    	}
    	public static void main(String[] args) {
    		int[] arr = new int[80000];
    		for (int i = 0; i < 80000; i++) {
    			arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
    		}
    
    		Date date1 = new Date();
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//SimpleDateFormat是Java提供的一个格式化和解析日期的工具类
    		String date1Str = simpleDateFormat.format(date1);
    		System.out.println("冒泡排序前的时间是:" + date1Str);
    		bubblesort(arr);
    		Date date2 = new Date();
    		String date2Str = simpleDateFormat.format(date2);
    		System.out.println("冒泡排序后的时间是:" + date2Str);
    	}
    }
    
    
    冒泡排序前的时间是:2021-01-31 11:38:30
    冒泡排序后的时间是:2021-01-31 11:38:38
    

    冒泡排序测试80000个数据一共需要8s左右的时间。

    PS:
    (1)常用的时间元素和字母的对应表如下:
    在这里插入图片描述
    (2)常用的输出格式的表示方法如下表:
    在这里插入图片描述

    展开全文
  • 冒泡排序法进行优化,比较的次数减少,效率提高
  • 冒牌排序可谓最基本的排序算法之一,稳定而没有优化空间:D 下面就一起来看一下Swift代码实现冒泡排序算法的简单实例:
  • 课程的随堂作业,C语言的,用dev就能运行,萌新代码,勿喷,仅仅帮助不想写作业的朋友方便一下,反正老师也不会仔细检查的
  • 本篇文章主要介绍了python实现冒泡排序的两种方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • js代码-冒泡排序算法

    2021-07-14 23:09:05
    js代码-冒泡排序算法
  • TIA博途中实现冒泡排序的两种SCL语言算法
  • 在STM8S003单片机上实现数组排序,用3种冒泡排序法对数组进行排序,并通过串口打印排序过程。
  • 冒泡排序算法是很多学习计算机的人必修的一种最基础的算法。今天在网上找了很多代码,发现有c++的,有Ruby的,有Java的等等,就是很少找到php的,于是我就自己写了一下php的冒泡排序算法,希望对大家有所帮助。
  • 冒泡排序算法,C语言冒泡排序算法详解

    万次阅读 多人点赞 2020-07-03 02:53:16
    冒泡排序是最简单的排序方法,理解起来容易。虽然它的计算步骤比较多,不是最快的,但它是最基本的,初学者一定要掌握。 冒泡排序的原理是:从左到右,相邻元素进行比较。每次比较一轮,就会找到序列中最大的一个或...

    冒泡排序是最简单的排序方法,理解起来容易。虽然它的计算步骤比较多,不是最快的,但它是最基本的,初学者一定要掌握。

    冒泡排序的原理是:从左到右,相邻元素进行比较。每次比较一轮,就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。

    以从小到大排序为例,第一轮比较后,所有数中最大的那个数就会浮到最右边;第二轮比较后,所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较,最后实现从小到大排序。

    比如对下面这个序列进行从小到大排序:
    90 21 132 -58 34

    第一轮:

    1. 90 和 21比,90>21,则它们互换位置:
      21 90 132 -58 34

    2. 90 和 132 比,90<132,则不用交换位置。

    3)132 和 –58 比,132>–58,则它们互换位置:
    21 90 -58 132 34

    4)132 和 34 比,132>34,则它们互换位置:
    21 90 -58 34 132

    到此第一轮就比较完了。第一轮的结果是找到了序列中最大的那个数,并浮到了最右边。

    比较时,每轮中第 n 次比较是新序列中第 n 个元素和第 n+1 个元素的比较(假如 n 从 1 开始)。

    第二轮:

    1. 21 和 90 比,21<90,则不用交换位置。

    2. 90 和 –58 比,90>–58,则它们互换位置:
      21 -58 90 34 132

    3. 90 和 34 比,90>34,则它们互换位置:
      21 -58 34 90 132

    到此第二轮就比较完了。第二轮的结果是找到了序列中第二大的那个数,并浮到了最右边第二个位置。

    第三轮:

    1. 21 和 –58 比,21>–58,则它们互换位置:
      -58 21 34 90 132

    2. 21 和 34 比,21<34,则不用交换位置。

    到此第三轮就比较完了。第三轮的结果是找到了序列中第三大的那个数,并浮到了最右边第三个位置。

    第四轮:

    1. –58 和 21 比,–58<21,则不用交换位置。

    至此,整个序列排序完毕。从小到大的序列就是“–58 21 34 90 132”。从这个例子中还可以总结出,如果有 n 个数据,那么只需要比较 n–1 轮。而且除了第一轮之外,每轮都不用全部比较。因为经过前面轮次的比较,已经比较过的轮次已经找到该轮次中最大的数并浮到右边了,所以右边的数不用比较也知道是大的。

    废话也不多说了,直接上码

    #include <stdio.h>
    void main()
    { 
    	int num,n,temp;//定义变量
    	int a[100];   //初始化数组
        printf("您要重新排列多少个数:  \n");
    	scanf("%d",&num);
    	n=num;  //获取数组的长度    另外还有一种:n = sizeof(a) / sizeof(a[0]);  
    			/*a[0]是int型, 占4字节, 所以总的字节数除以4等于元素的个数*/
    	int i=0;
    	printf("请您输入排列的数:\n");
    	while ( scanf("%d",&a[i]) && num >1)  //循环向数组中存入数
    	{
    		i++;
    		num--;
    	}
    	printf("排列之前的顺序为:");
    	for (int length=0;length<n;length++)
    	{
    		printf("%3d",a[length]);
    	}
    	 for (int j=0; j<n-1; j++)  //比较n-1轮
        {
            for (int k=0; k<n-1-j; k++)  //每轮比较n-1-j次,
            {
                /*
    			if (a[k] < a[k+1]) //从大到小
                {
                    temp = a[k];
                    a[k] = a[k+1];
                    a[k+1] = temp;
                }
    			*/
    			if (a[k] > a[k+1]) //从小到大
    			{
    				temp = a[k];
    				a[k] = a[k+1];
    				a[k+1] = temp;
    			}
            }
    	 }
    	printf("\n");
    	printf("排列之后的顺序为:");
    	for (int len=0;len<n;len++)
    	{
    		printf("%3d",a[len]);
    	}
    	printf("\n");
    }
    

    结果如下图所示:
    在这里插入图片描述
    有人或许会问程序中,为什么每轮比较的次数是 k<n–1–j,而不是 k<n–1?


    因为冒泡排序有一个特点,这个程序是从小到大排序,所以第一轮排序以后,最大的数就会浮到最右面;第二轮排序以后,第二大的数会浮到倒数第二个位置;第三轮排序以后,第三大的数会浮到倒数第三个位置……也就是说,排序多少轮,就有多少个数字已经按排序要求排好了,它们不需要再比较。写 k<n–1 也可以,只不过程序在执行时多做了许多无用功。

    展开全文
  • 冒泡排序法改进前后的比较,比较了其优点及缺点
  • 提示:冒泡排序算法是非常重要的算法,一定要熟练掌握。思路可以参考一位大佬博主的博客:帅地。介绍的十分详细,理解了之后,可以参考我的代码 ,是入门级别的,比较好懂。关于时间复杂度是数据结构的内容,没学过...

    提示:冒泡排序算法是非常重要的算法,一定要熟练掌握。思路可以参考一位大佬博主的博客:帅地。介绍的十分详细,理解了之后,可以参考我的代码
    ,是入门级别的,比较好懂。关于时间复杂度是数据结构的内容,没学过的请至我的博客:【数据结构】时间复杂度。


    一、代码的实现

    #include<stdio.h>
    void bubble_sort(char* a, int sz)
    {
    	int i = 0;
    	int j = 0;
    	int temp = 0;
    	//标记法:如果一开始或中途就已经排序完成
    	//我们就要及时终止循环,不然前面都排好了,我们为什么还要在那一个个交换,岂不是浪费时间?
    	//所以我们要判断什么时候排序完成,就用标记法
    	//每趟都要判断是否已经排序好了
    	int flag = 0;
    	for (i = 0; i < sz - 1; i++)//趟数
    	{
    		flag = 1;
    		//比较次数
    		//第一趟,俩俩比较9次,找最大的泡泡都排排到最右边,既然一个大泡泡已经排序好了
    		//即还剩9个泡泡还没排序,第二趟,俩俩比较8次(比较次数减一),找到剩下的9个泡泡
    		//的较大泡泡排到倒数第二个位置,依次下去
    		for (j = 0; j < sz - 1 - i; j++)
    		{
    			if (a[j] > a[j + 1])
    			{
    				//学习交换两个变量时,灵活应用临时变量
    				temp = a[j];
    				a[j] = a[j + 1];
    				a[j + 1] = temp;
    				//如果进入这,就说明还没排序好
    				flag = 0;
    			}
    		}
    		if (flag == 1)
    		{
    			break;
    		}
    	}
    }
    int main()
    {
    	char arr[] = { 0,1,2,3,4,5,6,7,8,9 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	int i = 0;
    	bubble_sort(arr, sz);
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }
    

    二,冒泡排序的时间复杂度

    假设我们只冒泡排序4个数,也就是我们需要排序3趟,第一趟比较俩俩比较3次,第二趟2次,第三趟1次,合起来一共3+2+1=6次。按照这样的算法,如果我们要冒泡排序N个数,也就是我们需要冒泡排序N-1趟,即我们一共要比较(N-1)+(N-2)+(N-3)+(N-4)+…+3+2+1=(N-1)(1+N-1)/2=N(N-1)/2。所以根据时间复杂度的算法,冒泡排序法的时间复杂度为O(N^2)。

    展开全文
  • 冒泡排序算法本文转载自头条文章原文章地址1、bubble_sort.mfunction y=bubble_sort(x)x_len=length(x);for i=1:x_len-1for j=1:x_len-iif(x(j)>x(j+1))[x(j),x(j+1)]=swap(x(j),x(j+1));endenddisp([num2str(i),...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是...
  • 冒泡排序算法及代码

    千次阅读 2022-03-23 23:21:46
    冒泡排序一、算法思想二、具体代码 一、算法思想 冒泡排序算法:其实相当简单,从头或尾开始(假如从数组头开始)每次比较当前元素和后一个元素,如果当前元素大于后一个元素,则将他们交换。这样一趟排序下来就会...
  • 主要介绍了Javascript冒泡排序算法的相关资料,需要的朋友可以参考下
  • Java冒泡排序算法

    2013-12-22 22:55:52
    Java语言实现的冒泡排序算法,代码里头有详细注释,注释皆为简单英文,这个算法比较经典,欢迎新手下载学习使用,欢迎后期的学习交流!
  • 冒泡排序算法(java)

    2022-01-20 21:57:56
    冒泡排序(Bubble Sort),是一种计算机领域的较简单的p排序算法。 它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地...
  • 主要介绍了浅析java双向冒泡排序算法,并附上源码,需要的朋友可以参考下
  • C++常见排序算法——冒泡排序算法

    千次阅读 2021-10-15 08:50:11
    首先说一下冒泡排序的基本算法思想: 它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。 这个算法的名字由来是因为越小的元素会经由交换慢慢...
  • python 冒泡排序算法(超级详细)

    千次阅读 2021-12-20 10:52:51
    冒泡排序是一种简单的排序算法,它也是一种稳定排序算法。其实现原理是重复扫描待排序序列,并比较每一对相邻的元素,当该对元素顺序不正确时进行交换。一直重复这个过程,直到没有任何两个相邻的元素可以交换,就...
  • C语言 冒泡排序算法 冒泡排序(Bubble Sort)是一种简单的排序算法...冒泡排序是与插入排序拥有相等的执行时间,但是两种在需要的交换次数却很大地不同。在最坏的情况,冒泡排序需要O(n2)次交换,而插入排序只要最多
  • 数组应用及冒泡排序算法示例,适用于初学者
  • 十大经典排序算法-冒泡排序算法详解

    万次阅读 多人点赞 2020-05-30 10:18:51
    冒泡排序(Bubble Sort)是排序算法里面比较简单的一个排序。它重复地走访要排序的数列,一次比较两个数据元素,如果顺序不对则进行交换,并一直重复这样的走访操作,直到没有要交换的数据元素为止。 2.算法原理 这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,169
精华内容 75,267
关键字:

冒泡排序法

友情链接: Fingerprint.zip