冒泡排序、递归

冒泡排序方法

第一种方法：

比较相邻的两个元素,如果前一个比后一个大，就会交换位置
第一次比较时将最大的元素放到了最后面
由于每次排序最后一个都是最大的，所以之后按照步骤1排序最后一个元素 不用比

function arr(data) {
	var temp
	for(var i = 0; i<data.length-1;i++) {
		for(var j = 0; j<data.length - i; j++) {
			if(data[j]) > data[j + 1]) {
				a = data[j + 1]
				data[j] = data[j + 1]
				data[j + 1] = a
			}
		}
	}
}
arr(arr)

第二种方法:

声明一个变量标记顺数是否发生变化

function arr_sort(data) {
	let n = data.length
	let flag = true // 标记顺数是否发生变化
	let swap
	while(flag) {
		flag = false
		for(var j = 1; j<n; j++) {
			if(data[j - 1] > data[j]){
				swap = data[j - 1]
				data[j - 1] = data[j]
				data[j] = swap
				flag = true
			}
		}
		n--
	}
	return data
}
arr_sort(arr)

第三种方法

第一遍排序时将数据分成两部分，一部分比另一部分的所有数据都要小。然后递归调用，在两边都实行排序。

function arr_sort(data) {
		if(data.length <= 1) {
			return arr
		}
	
		var pIndex = Math.floor(data.length/2)
		var p = data.splice(pIndex, 1)[0]
		var left = []
		var right = []
		for(var i = 0; i<data.length; i++) {
			if(data[i] < p) {
				left.push(arr[i])
			} else {
				right.push(arr[i])
			}
		}
		return arr_sort(left).concat([p], arr_sort(right))
	}

递归

递归指的是在函数的定义中使用函数自身的方法。说白了，就是自己调用自己，使用递归函数时一定要注意，处理不当就会进入死循环。

function fn(){
	fn();	//在函数内部执行自己
}	
fn();	//执行函数 没有终止条件，这个递归就是一个死循环。

递归的优点：递归的实现明显要比循环简单得多

递归的缺点：效率低、性能差

//如果写一个 1~100 的和，可能大部分人都会这样写
var sum = 0;
for(let i = 1; i <= 100; i++) {
    sum += i;
}
console.log(sum) // 最后相加的结果为 5050


//如果使用递归，我们该怎样计算1-100的和呢？
//使用递归求 1-100 的和，也就是 sum(100)，我们可以列出以下公式：
var result = sum(100);
var result = sum(99) + 100;
var result = sum(98) + 100;
var result = sum(97) + 100;
var result = sum(96) + 100;
...
//那么我们就可以知道，通过这个公式我们就可以拿到和
var result = sum(n-1) + n;
//转化为递归方式就是
function sum(n) {
    return sum(n-1) + n;
}
//但是按我们上面所说，使用递归的时候，一定要加上临界条件，否则就会陷入死循环。
//那在计算1-100的和的临界条件是什么呢？
//我们可以这样想：
//求100的时候转换为求99；
//求99的时候转换为求98；
//求98的时候转换为求97；
//求97的时候转换为求96；
//...
//求2的时候转换为求1；
//求1的时候转换为求？
//所以，这里我们就得加上临界条件，即sum(1) = 1;
function sum(n) {
    if(n === 1){
    	return 1
    } 
    return sum(n-1) + n;
}
sum(100)
// 5050