【算法】————1、冒泡排序

前言

最近感觉自己的思维不是非常灵活，所以想看看算法了，顺便就整理一下之前的内容，做个小记录吧！

排序算法

排序是计算机程序设计中的一种重要的操作，其功能是将一个任意序列的数据元素，通过排序算法重新排列成一个按关键字有序的序列。

a、排序的定义：对一序列对象根据某个关键字进行排序

输入：n个数：a1,a2,a3,...,an
输出：n个数的排列:a1',a2',a3',...,an'，使得a1'<=a2'<=a3'<=...<=an'。
讲的形象点就是排排坐，调座位，高的站在后面，矮的站在前面咯。

b、对于评述算法优劣术语的说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度: 一个算法执行所耗费的时间。
空间复杂度: 运行完一个程序所需内存的大小。

c、排序算法图片总结(图片来源于网络):

排序对比：

图片名词解释： 

• n: 数据规模
• k:“桶”的个数
• In-place: 占用常数内存，不占用额外内存
• Out-place: 占用额外内存

排序分类：

 

冒泡排序

a、算法简介：

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，依次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

b、算法描述和实现

具体算法描述如下：

• <1>.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• <2>.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• <3>.针对所有的元素重复以上的步骤，除了最后一个；
• <4>.重复步骤1~3，直到排序完成。

c、代码实现

C语言：

#include <stdio.h>
#define  N 10

int main(void){
	int i,j;
	int temp;//排序过程中用于存储临时数据的临时变量
	int a[N]={72,41,2,45,5,83,3,37,82,45};

	for(i=0;i<N-1;i++){
		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;
			}
		}
	}
	//循环输出
	for(i=0;i<N;i++){
		printf("%d   ",a[i]);
	}
	printf("\n");
	return 0;
}

拓展：我们可以对以上代码进行优化，优化方式如下：

#include <stdio.h>
#define  N 10

int main(void){
	int i,j;
	int temp;//排序过程中用于存储临时数据的临时变量
	int flag=0;//标志，用户判断是否已经完成排序
	int a[N]={72,41,2,45,5,83,3,37,38,39};

	for(i=0;i<N-1;i++){
		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){//当flag为0时表示后续部分已经有序了！
			break;
		}
	}
	//循环输出
	for(i=0;i<N;i++){
		printf("%d   ",a[i]);
	}
	printf("\n");
	return 0;
}

运行效果如下：

JavaScript：

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        //相邻元素两两对比
                var temp = arr[j+1];        //元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(bubbleSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

优化：

Java:

package Algorithm;

import java.lang.reflect.Array;

public class Bubble {
    public static void main  (String[] args) {
        int[] arr={12,45,23,14,89,45,34,77,69,80,100,24,11};
        int temp=0;
        for (int i = arr.length - 1; i > 0; --i) { // 每次需要排序的长度
            for (int j = 0; j < i; ++j) { // 从第一个元素到第i个元素
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }//loop j
        }//loop i

        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
            System.out.print("  ");
        }
    }
}

运行效果：

优化：

package Algorithm;

import java.lang.reflect.Array;

public class Bubble {
    public static void main  (String[] args) {
        int[] arr={12,45,23,14,89,45,34,77,69,80,100,24,11};
        int temp=0;
        int flag=0;
        for (int i = arr.length - 1; i > 0; --i) { // 每次需要排序的长度
            for (int j = 0; j < i; ++j) { // 从第一个元素到第i个元素
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag=1;
                }
            }//loop j
            if(flag==0)
                break;
        }//loop i

        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
            System.out.print("  ");
        }
    }
}

d、算法稳定性

容易看出，在相邻元素相等时，我们并不需要交换它们的位置，所以，冒泡排序是稳定排序。

e、算法适用场景

冒泡排序思路简单，代码也简单，特别适合小数据的排序。但是，由于算法复杂度较高，在数据量大的时候不适合使用。如果一定要在较多数据的时候使用，最好对算法加以改进，例如选择排序法。