排序-＞冒泡排序

冒泡排序

最简单排序实现（初级版）

冒泡排序是一种交换排序，它的基本思想：两两比较相邻记录关键字，如果反序则交换，直到没有反序的记录为止。（引用于大话数据结构379页）

好像概念解释不是很难啊，但是写代码的时候总是会被其中两个循环里的i, j的范围给搞混。
所以，我就做了对一个数组排序的详细过程的演示。
演示数组：arr = [6, 2, 4, 1, 3]，数组长度：len=5；
i用来表示当前是第几轮排序，从1开始。
j用来表示数组索引。

第一轮排序：i=1，由下图可以看到第一轮排序总共进行了4次（len-i=5-1=4），且数组中最大的数已经被放到数组的最后一位，所以后续不用对arr[3]和arr[4]进行比较。

第二轮排序：i=2，由下图可以看到第二轮排序总共进行了3次（len-i=5-2=3），且数组中较大的数已经被放到数组的倒数第二位，所以后续也不用对arr[2]和arr[3]进行比较。

第三轮排序：i=3，由下图可以看到第三轮排序总共进行了2次（len-i=5-3=2），且数组中较大的数已经被放到数组的倒数第三位，所以后续也不用对arr[1]和arr[2]进行比较。

第四轮排序：i=4，由下图可以看到第四轮排序总共进行了1次（len-i=5-4=1），此时，数组中的arr[0]和arr[1]也已经排好，即数组排序已经完成。

上面演示过程中可以看出，数组长度为len=5，总共进行了4轮，即len-1轮排序，因为i=1，由此得出可设置i<len或者i<=len-1。同理，每一轮排序分别进行len-i次，又因为j表示索引，从0开始，所以设置j<len-i。

源码：
C语言版本

#include <stdio.h>
#include <stdlib.h>
int* BuubleSort(int a[], int len);

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) {
	int a[5] = {6, 3, 2, 1, 4};
	int len = sizeof(a)/sizeof(a[0]);
	for(int i=1; i<len; i++){
		for(int j=0; j<len-i; j++){
			if(a[j] > a[j+1]){
				int tmp = a[j+1];
				a[j+1] = a[j];
				a[j] = tmp;
			}
		}
	}
	for(int i=0; i<len; i++){
		printf("%d\n", a[i]);
	}
	return 0;
}

JavaScript版本：

var a = [6, 3, 2, 1, 4];
for(let i=1; i<a.length; i++){
    for(let j=0; j<a.length - i; j++){
        if(a[j] > a[j+1]){
            let tmp = a[j+1];
            a[j+1] = a[j];
            a[j] = tmp;
        }
    }
}
a.forEach(value=>console.log(value));

冒泡排序算法（正宗）

代更…

参考资料：

1. 《大话数据结构》

看到的其它冒泡排序的写法（js实现）

第一版

function bubbleSort(arr){
	const len = array.length;
    for(let i=0; i<len; i++){
      for(let j=0; j<len-1; j++){
        if(array[j] > array[j+1]){
            swap(array, j, j+1)
          }
        }
    }
}

第二版

function bubbleSort(arr){
	const len = arr.length
	for(let i=0; i<len; i++){
		for(let j=0; j<len-1-i;j++){
			if(arr[j]>arr[j+1]){
				[arr[j], arr[j+1]] = [arr[j+1], arr[j]]
			}
		}
	}
}