冒泡排序法
 
冒泡排序法原理示意图
 
 
 
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));
	}

什么是冒泡排序呢？冒泡排序的英语名是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.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

冒泡排序法(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即说明未发生交换，排序完成
    }
}