各种算法，冒泡排序，二分查找，去重

1：排序
正常排序，从小到大：

var a = [13, 6, 100, 4, 8];
function b(c,d){
	return c-d
}
a.sort(b);
console.log(a,888888)// [4, 6, 8, 13, 100] 888888
</script>

冒泡排序： （利用循环的方法进行）具体过程可以打debugger查看逻辑

//		由此可以看出，将相邻的两个数依次相比较，大数向后放，小数向前移。即是位置交换实现小数在前，大数在后。经过10次比较后，最终实现重排。
		var a = [13, 6, 100, 4, 8, 55, 3, 45];
		//外层循环：控制比较轮数 从0开始，次数小于长度-1
		function sortNum(a){
			for(var i = 1; i < a.length; i++) {
			//内层循环：控制每轮比较次数  数组长度-i
			for(var j = 0; j <a.length - i; j++) {
				//如果当前的元素(j)大于下一个元素(j+1)，则交换位置
				if(a[j] >a[j + 1]) {
					var t = a[j];
					a[j] = a[j + 1];
					a[j + 1] = t;
				}
			}
		}
		}
		sortNum(a)
		console.log(a, 66666666666) //[3, 4, 6, 8, 13, 45, 55, 100] 66666666666
//	如果从大到小排序的话，则将if(arr[j]>arr[j+1])改为if(arr[j]<arr[j+1])即可

2：二分查找：是一种搜索某个值的索引的算法。
　　思路：1.将数组折半，分成左右两个数组。
　　　　　2.判断要查找的数和中间位置数值的大小，来判断要查找的数实在哪一半。
　　　　　3.之后继续折半查找，直至找到这个数。
　　　　　https://www.cnblogs.com/zhang-wang/p/7530126.html

var arr = [1, 5, 6, 2, 44, 66, 32, 77, 8, 9]
function search(arr, data) {
			var max = arr.length - 1, //最大值
				min = 0; //最小值
			while(min <= max) {
				var mid = Math.floor((max + min) / 2); //中间值
				if(arr[mid] < data) {
					min = mid + 1;
				} else if(arr[mid] > data) {
					max = mid - 1;
				} else {
					return mid;
				}
			}
			return -1; //没找到返回-1
}   
		console.log(arr); //[1, 2, 5, 6, 8, 9, 32, 44, 66, 77]
		console.log(search(arr, 8)); //4 
		console.log(search(arr, 104)); //-1
	

3：去重
实现思路：新建一个数组，遍历要去重的数组，当值不在新数组的时候（indexOf 为 -1）就加入该新数组中；

        function unique(arr){
        	var newArr=[]
        	for(i=0;i<arr.length;i++){
        		if(newArr.indexOf(arr[i])==-1){
        			newArr.push(arr[i])
        		}
        	}
        	return newArr
        }
		var arr = [1, 1, 1, 2, 44, 66, 8, 77, 8, 9]
        var newArr=unique(arr)
        console.log(newArr,6666666666) //[1, 2, 44, 66, 8, 77, 9] 6666666666
方法二：ES6 新增 Set 和 …（拓展运算符）可以很简单的进行数组去重。
	var arr=[1,1,2,2,56]
	arr = [...new Set(arr)]
//[1,2,56]

3：红黑树，B+树。