小算法大世界之冒泡排序VS选择排序

【声明：全新原创，欢迎转载，如果发现文章错误或者有好的意见与建议希望指点下~！】

进入主题，本次文章的主要算法是冒泡排序与选择排序。

冒泡排序（bubble sort）：顾名思义，就是把大的数想气泡一样一个个排到最顶端。

算法思想：从数组的第一个数开始（设数组一共有n个数据）：

    1.从第一个数开始，将第一个数与第二个数比较，如果第一个数大于第二个数，那么交换第一个数与第二个数，如果第二个数大于第一个数，则不变。然后比较第二个与第三个，一次类推，直到比较完第n-1个和第n个，一直需要比较n-1次。（注：第一趟结束后最后一个数为最大的数，第二趟结束后倒数第二个为第二大的数）

    2.第一趟完成后将重复上面的步骤，直到没有任何一个数需要比较。

例如：无序数列：11，22，4，5，38，9，14，56，78，49

                第一趟：11，4，5，22，9，14，38，56，49，78

第二趟：4，5，11，9，14，22，38，49，56，78

。。。。。。

直到最后一趟排出有序数列。

冒泡排序的时间复杂度分析：

很明显：对于冒泡排序来说，最好的情况是顺序，此时只需要比较n-1次，时间复杂度是O(n);

               最差的情况是逆序，此时需要比较n-1趟，每趟需要比较n-i个数，所以最坏的时间复杂度为O(n²)。

综上所诉，冒泡排序的时间复杂度为O(n²)。

注：冒泡排序是一种稳定的算法。

下面给出冒泡排序的JAVA实现：

class bubbleSort
{
int temp = 0;//临时变量
public void sort(int []arr)
{
for(int i=0;i<arr.length-1;i++)//最多做n-1趟排序
{
for(int j=0;j<arr.length-1-i;j++)//每一次都是比较两个数
     //然后把较大的数据换到后面
{
if(arr[j]>arr[j+1])
{
temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
}
}

冒泡排序的代码很简单，第一层循环是比较比较次数，第二层循环是交换数据。

选择排序(selection sort)：

算法思想：

  1.就是先假设第一个数为最小的数(即假设arr[0]最小)，然后从第一个数开始遍历数组选择出一个最小的(最大的)与arr[0]交换。

2.从第二个数开始遍历数组，选择一个最小的(最大的)与arr[1]交换，然后不断重复这个步骤，直到排序结束。

    例如：38，20，46，74，91，12

第一趟：12，20，46，74，91，38

第二趟：12，20，46，74，91，38

第三趟：12，20，38，74，91，46

。。。。。。

直到排序结束。

选择排序的时间复杂度分析：

选择排序无论最好还是最坏都是O(n²)。但是性能上要优于冒泡排序。后文中会给出两个排序的时间消耗，一看就知道了。

注：选择排序不是一种稳定的排序。

下面给出选择排序的JAVA实现：

class selectionSort{
public void Sort(int arr[])
{
int temp = 0;//用来交换的变量
//该循环比较n次，n为数组长度
for(int j=0;j<arr.length-1;j++)
{
int min = arr[j];//认为第一个数最小
int index = j;//最小数的下标为j
for(int k = j+1;k<arr.length;k++)
{
//开始比较，从第一个数开始，第一个数与第二个数比较
if(arr[k]<min)
{
//如果第一个数大于第二个数，则记录小第二个数的下标
//且认为第二个数为最小的数
index = k; 
min = arr[k];
} 
}
//该层循环结束时，就找出了第一个最小的数，此时需要
//将第一个最小的数放到arr[j]的位置
temp = arr[j];
arr[j] = arr[index];
arr[index] = temp;
//此时，arr[j]是最小的数
}
}
}

经过测试，两种排序的代码都能正确运行，为了更能说明选择排序的性能会略优于冒泡排序，这里我随机生成10000个数据，用来测试时间消耗。

代码如下：

public static void main(String []arg)
{
//测试冒泡排序
System.out.println("测试冒泡排序");
int arr[]={17,3,4,5,8,9,0,12,54,22,55,76,88,100,65,78,99};
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println();
bubbleSort bubblesort = new bubbleSort();
bubblesort.sort(arr);
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println();
System.out.println("---------------------------------------------");
//测试选择排序
System.out.println("测试选择排序");
int arr1[] = {17,3,4,5,8,9,0,12,54,22,55,76,88,100,65,78,99};//测试数据
for(int i=0;i<arr1.length;i++)
{
System.out.print(arr1[i]+" ");
}
System.out.println();
selectionSort selSort = new selectionSort();
selSort.Sort(arr1);
for(int i=0;i<arr1.length;i++)
{
System.out.print(arr1[i]+" ");
}

//下面测试两种排序消耗的时间
int len = 10000;
int[] arr2 = new int[len];
//该循环随机产生len个1到10000的数
for(int i = 0;i<len;i++)
{
//随机产生一个1到10000的数
int t = (int)(Math.random()*10000);
arr2[i] = t;
}
System.out.println();
//冒泡排序的时间测试
System.out.println("测试数据个数:"+len+"个");
bubbleSort bubble1 = new bubbleSort();
long start1 = System.currentTimeMillis();
bubble1.sort(arr2);
long end1 = System.currentTimeMillis();
System.out.println("冒泡排序的时间:"+(end1-start1)+"毫秒");

//选择排序的时间测试
selectionSort selSort2 = new selectionSort();
long start2 = System.currentTimeMillis();
selSort2.Sort(arr2);
long end2 = System.currentTimeMillis();
System.out.println("选择排序的时间:"+(end2-start2)+"毫秒");
}

  运行结果如下：

很明显的看出，选择排序会快于冒泡排序。

注：虽然选择排序快于冒泡排序，但是选择排序不是一种性能很好的排序，因为它的时间复杂度是O(n²)，在数据很少的时候可以使用，一旦数据量很大时就不推荐使用了。

全文到此结束，过段时间会写上快速排序等其他性能很高的排序。

最后感谢阅读，卖个萌o(∩_∩)o 哈哈~！