精华内容
下载资源
问答
  • 冒泡排序法

    万次阅读 多人点赞 2019-08-05 20:41:40
    冒泡排序法 冒泡排序法原理示意图 public static void ArraySortTest() { int[] ages= {21,27,31,19,50,32,16,25}; System.out.println(Arrays.toString(ages)); //控制比较轮数 for(int i=1;i<ages....

    冒泡排序法

    冒泡排序法原理示意图
    在这里插入图片描述
    在这里插入图片描述

    public static void ArraySortTest() {
    
    		int[] ages= {21,27,31,19,50,32,16,25};
    		System.out.println(Arrays.toString(ages));
    		//控制比较轮数
    		for(int i=1;i<ages.length;i++) {
    			//每轮比较多少
    			for(int j=0;j<ages.length-i;j++) {
    				if(ages[j]>ages[j+1]) {
    					int tmp=0;
    					tmp=ages[j];
    					ages[j]=ages[j+1];
    					ages[j+1]=tmp;					
    				}
    			}
    		}
    		System.out.println(Arrays.toString(ages));
    	}
    
    展开全文
  • 冒泡排序算法

    万次阅读 多人点赞 2018-07-19 22:31:43
    什么是冒泡排序呢?...而冒泡排序之所以叫冒泡排序,正是因为这种排序算法的每一个元素都可以向小气泡一样,根据自身大小,一点一点向着数组的一侧移动。具体如何移动呢?我们来看一下例子:  有...

    什么是冒泡排序呢?冒泡排序的英语名是Bubble Sort,是一种最基础的交换排序。

         大家一定都喝过汽水吧,汽水中常常有许多小小的气泡,往上飘,这是因为组成小气泡的二氧化碳比水要轻,所以小气泡才会一点一点的向上浮。而冒泡排序之所以叫冒泡排序,正是因为这种排序算法的每一个元素都可以向小气泡一样,根据自身大小,一点一点向着数组的一侧移动。具体如何移动呢?我们来看一下例子:

        有8个数组组成一个无序数列:5,8,6,3,9,2,1,7,希望从大到小排序。按照冒泡排序的思想,我们要把相邻的元素两两进行比较,根据大小交换元素的位置,过程如下:

    第一轮排序:

    1、首先让5和8进行交换,发现5比8小,因此元素位置不变。

    2、接下来让8和6比较,发现8比6大,所以要交换8和6的位置。3、

     3、继续让8和3比较,发现8比3要大,所以8和3 交换位置。

     4、继续让8和9进行比较,发现8比9小,不用交换

     5、9和2进行比较,发现9比2大,进行交换

    6、继续让9和1进行比较,发现9比1大,所以交换9和1的位置。

    7、最后,让9和7交换位置

    这样一来,元素9作为数列的最大元素,就已经排序好了。

     下面我们来进行第二轮排序:

    1、首先让5和6比较,发现5比6小,位置不变

    2、接下来让6和3比较,发现6比3大,交换位置

    3、接下来让6和8比较,6比8小,位置不变

    4、8和2比较。8比2大,交换位置

    5、接下来让8和1比较,8比1大,因此交换位置

    6、继续让8和7比较,发现8比7大,交换位置

    第二轮的状态为:

    第三轮的状态为:

    第四轮的状态为:

    第五轮的状态为:

    第六轮的状态:

    第七轮状态为:(已经有序了)

    第八轮的状态为:

    到此为止,所有的元素欧式有序的了,这就是冒泡排序的整体思路。

    原始的冒泡排序是稳定的,由于该排序算法的每一轮都要遍历一遍所有的元素,轮转的次数和元素数量相当,所以时间复杂度为O(N^2)。

    方法一:

    #include<stdio.h>
    #include<stdlib.h>
    
    void BubbleSort(int a[], int len)
    {
    	int i, j, temp;
    	for (j = 0; j < len - 1; j++)
    	{
    		for (i = 0; i < len - 1 - j; i++)
    		if (a[i] > a[i + 1])
    		{
    			temp = a[i];
    			a[i] = a[i + 1];
    			a[i + 1] = temp;
    		}
    	}
    }
    
    int main()
    {
    	int arr[] = { 5, 8, 6, 3, 9, 2, 1, 7 };
    	int len = sizeof(arr) / sizeof(arr[0]);
    	int i = 0;
    	printf("排序前:");
    	for (i = 0; i < len; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    
    	BubbleSort(arr, len);
    	printf("排序后:");
    	for (i = 0; i < len; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }

        这个代码很简单,使用双循环的方式进行排序。外部的循环控制所有回合,内部循环代表每一轮的冒泡处理,先进行元素比较,再进行元素交换。那么这个代码该怎么进行优化呢??我们现在来回顾一下之前的描述细节,仍然以 5,8,6,3,9,2,1,7 为例,当排序伏安法分别执行到第六、第七、第八轮的时候,数列的状态其实已经变为有序的了。

    第六轮状态:

    第七轮状态:

    第八轮状态: 

        在这种情况下,我们就不必要对这几次在重新进行排序,这样就会减少执行的次数,因此,我们可以进行一个优化,就是设置一个flags,如果已经排序了那么设置为0;如果不是有序的,那么设置为1。现在我们来看看优化后的代码。

    #include<stdio.h>
    #include<stdlib.h>
    
    void BubbleSort(int a[], int len)
    {
    	int i, j, temp;
    	int flags = 0;
    	for (j = 0; j < len - 1; j++)
    	{
    		for (i = 0; i < len - 1 - j; i++)
    		{
    			if (a[i] > a[i + 1])
    			{
    				temp = a[i];
    				a[i] = a[i + 1];
    				a[i + 1] = temp;
    				flags = 1;//不是有序的,flags设置为1;
    			}
    		}
    		if (flags == 0)
    			return;
    	}
    }
    
    int main()
    {
    	int arr[] = { 5, 8, 6, 3, 9, 2, 1, 7 };
    	int len = sizeof(arr) / sizeof(arr[0]);
    	int i = 0;
    	printf("排序前:");
    	for (i = 0; i < len; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    
    	BubbleSort(arr, len);
    	printf("排序后:");
    	for (i = 0; i < len; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    	system("pause");
    	return 0;
    }

         这一个版本的代码只是做了一个小小的改动,利用fags做标记。如果在本轮排序中,元素有交换,则说明数列无序,如果没有交换,则说明数列已然有序,直接返回。

    展开全文
  • 冒泡排序算法本文转载自头条文章原文章地址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),...

    冒泡排序算法

    本文转载自头条文章原文章地址

    1、bubble_sort.m

    function y=bubble_sort(x)

    x_len=length(x);

    for i=1:x_len-1

    for j=1:x_len-i

    if(x(j)>x(j+1))

    [x(j),x(j+1)]=swap(x(j),x(j+1));

    end

    end

    disp([num2str(i),'.Sort:x=',num2str(x)]);

    end

    y=x;

    end

    function [a,b]=swap(x,y)

    a=y;

    b=x;

    end

    2、test.m

    clc;

    clear;

    X=randperm(9);

    disp(['Before Sort:X=',num2str(X)]);

    disp('--------------------');

    y=bubble_sort2(X);

    disp(['Bubble Sort:x=',num2str(y)]);

    3 bubble_sort2.m (optional)

    function y=bubble_sort2(x)

    x_len=length(x);

    flag=1;%flag为0,这说明已经排好序,不用继续循环

    for i=1:x_len-1

    if flag

    flag=0;

    for j=1:x_len-i

    if(x(j)>x(j+1))

    [x(j),x(j+1)]=swap(x(j),x(j+1));

    flag=1;%有交换 则说明还需要循环

    end

    end

    disp([num2str(i),'.Sort:x=',num2str(x)]);

    end

    end

    y=x;

    end

    function [a,b]=swap(x,y)

    a=y;

    b=x;

    end

    相关阅读

    public static void bubbleSort(int[] numbers) {   int temp; // 记录临时中间值   int size = numbers.lengt

    1. 冒泡排序基本思想:每一趟排序均从未排序元素开始,将未排序元素与其相邻元素进行比较,若不符合排序要求则进行交换后继续比较下一

    原理:每次比较两个相邻的元素,将较大的元素交换至右端。

    思路:每次冒泡排序操作都会将相邻的两个元素进行比较,看是否满足大小关系要

    前言这些一个系列的文章,主要是自己学习算法和数据结构的一些笔记整理。从最简单开始,一步步深入,都是自己学习过程中的领悟。对于程

    冒泡排序:一种交换排序,基本思想是两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止1.容易理解的代码:

    void BubbleSo

    展开全文
  • 主要介绍了Java实现冒泡排序与双向冒泡排序算法的代码示例,值得一提的是所谓的双向冒泡排序并不比普通的冒泡排序效率来得高,注意相应的时间复杂度,需要的朋友可以参考下
  • 排序算法——冒泡排序法

    千次阅读 2016-07-14 21:30:31
    冒泡排序法(Bubble Sort)是所有排序算法中最简单,最基本的一种。冒泡排序法的基本思路就是交换排序,通过相邻数据的比较来达到排序的目的。冒泡排序法冒泡排序算法通过多次比较和交换数据来实现排序,其排序流程...

    冒泡排序法(Bubble Sort)是所有排序算法中最简单,最基本的一种。冒泡排序法的基本思路就是交换排序,通过相邻数据的比较来达到排序的目的。


    冒泡排序法

    冒泡排序算法通过多次比较和交换数据来实现排序,其排序流程如下:
    (1)对数组中的各元素依次比较相邻元素的大小。
    (2)如果前面的数据大于后面的数据,就交换这两个数据。经过第一轮排序,则最大值已经排到最后。
    (3)再用同样的方法将剩下的数据逐个比较,最终得到由小到大数组。

    为了更清晰的理解冒泡排序算法的流程。这里我们举一个实际数据的例子来一步步的执行冒泡排序。对5个整型数据118,101,105,127,112,这是一组无序数据。对其执行冒泡排序过程,如图4-2所示,冒泡排序算法执行步骤如下:

    这里写图片描述
    如图我们可以看出经过第一轮的四次排序,其中最大值已经排到了最末尾位置。继续排序即可实现所有数据由小到大显示。

       从上面的例子,我们可以非常直观的了解冒泡排序的执行过程。整个冒泡排序过程可以形象的类似于水泡的浮起过程,因此而得名。冒泡排序算法在对N个数据进行排序时,无论原数据有无顺序,都需要进行N-1步中间排序。这种排序思路简单直观,但是缺点就是执行的步骤有点长,效率不高。
       一种改进的方法,就是在每次中间排序之后,比较一下数据是否已经按照顺序排列完成。如果完成则退出排序过程,否则继续排序。这样,对于数据比较有规则的,可以加速算法的执行过程。
       冒泡排序算法代码如下:

    void bubbleSort(int[] a){
        int temp;    //用于交换数据
        int tag;    //判断排序提前完成
        for(int i=0;i<a.length;i++){
            tag=0;
        for(int j=0;j<a.length-i;j++){
            if(a[j]>a[j+1]){
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=a[j];    
                tag=1; //如果发生排序交换则tag=1;
            }
            }
            if(tag==0)break;//如果tag依旧等于0即说明未发生交换,排序完成
        }
    }
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 153,449
精华内容 61,379
关键字:

冒泡排序法