【算法】————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
#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;ia[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
//循环输出
for(i=0;i 
拓展：我们可以对以上代码进行优化，优化方式如下：
#include
#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;ia[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 运行效果如下：
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运行效果：
优化：
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
d、算法稳定性
容易看出，在相邻元素相等时，我们并不需要交换它们的位置，所以，冒泡排序是稳定排序。
e、算法适用场景
冒泡排序思路简单，代码也简单，特别适合小数据的排序。但是，由于算法复杂度较高，在数据量大的时候不适合使用。如果一定要在较多数据的时候使用，最好对算法加以改进，例如选择排序法。