基础算法小结

看了一部分排序，去重算法，也对自己有个小结，如果有新的算法，再更新。

插入排序：

基本思想：开始将数组分为有序数组和无序数组两部分，有序数组初始化长度为1(从原来数组中随机拿一个)，那么肯定是有序的。之后，从后往前遍历有序数组与无序数组中第一个元素比较，如果有序数组中值大，那么将有序数组位置向后+1，若比较完成找到合适的位置，插入无序数组第一个元素。

//插入排序
		var arr=[5,4,66,12,511,9,14,4,6,44,11,13];
		for(var i=0;i<arr.length;i++){ 		        //从arr[1]开始，那么无序数组初始化为arr
			var j;					//保存有序数组位置
			var temp=arr[i];			//得到无序数组中第一个元素
			for(j=i-1;j>=0&&temp<arr[j];j--){	//从后往前遍历有序数组，与无序数组第一个元素进行比较
				arr[j+1]=arr[j];		//将有序数组位置向后+1
			}
			arr[j+1]=temp;				//找到合适位置插入值
		}
		console.log(arr)

快速排序：

基本思想：从数组中找到一个值(一般是中间值，比较好理解arr[arr.length/2])作为基点，使用splice将基点从数组分离出来。将原数组中比基点小的数放在新数组left[ ]中，比基点大的或者等于的数放在新数组right[]中。反复使用上面步骤(其实就是一个递归运用)，知道每个子数组的length=1的时候return，最后得到排序好的数组。

//快速排序
		var arr=[5,4,66,12,511,9,14,4,6,44,11,13];
		function fSort(arr){
			if(arr.length<=1){			//递归函数设置执行条件，并返回值
				return arr;
			}
			var numIndex=Math.floor(arr.length/2);  //找到基点位置
			var num=arr.splice(numIndex,1)[0];	//保存基点位置的具体值,并将基点从原数组中删除
			var left=[];				//新建数组left
			var right=[];  				//新建数组right
			for(var i=0;i<arr.length;i++){		//遍历数组，将比基地值小的放在left[]，其他的放在right[]
				if(arr[i]<num){
					left.push(arr[i]);
				}else{
					right.push(arr[i]);
				}
			}
			return fSort(left).concat([num],fSort(right));//设置递归函数，最后拼接新函数
		}
		var x=fSort(arr);
		console.log(x)

冒泡排序：

基本思想：遍历数组，将数组中的数两两比较，若arr[i]>arr[i+1]那么将其交换位置。一遍下来，数组中最大的数将在最右边，然后重复使用上面算法，实现数组排序。

//冒泡排序
		var arr=[5,4,66,12,511,9,14,4];
		for(var k=1;k<arr.length;k++){ 		        //外层循环控制一共需要执行几次下面算法
			for(var i=0;i<arr.length-k;i++){	//内层函数控制将数组中最大数向后移动至末尾
				if(arr[i]>arr[i+1]){
					arr[i]+=arr[i+1];
					arr[i+1]=arr[i]-arr[i+1];
					arr[i]=arr[i]-arr[i+1];
				}
			}
		}

数组去重：

基本思想：建立新数组hash[ ](本质为关联数组)，遍历原数组，将原数组每个元素作为对象在hash[ ]中查询，若结果为undefined将元素作为新的对象进入hash[ ]，若其查询到，将hash[ ]中，对应对象值+1。最后遍历hash[ ]数组，将对象作为值赋值给arr，达到去重复。

//hash数组去重复
		var arr=[5,1,2,3,3,3,4,5,5,4,4,2,3,12,32,21,2,11,21,12];
		function del(arr){
			var hash=[];					//建立数组hash[]
			for(var i=0;i<arr.length;i++){	                //遍历原数组
				if(hash[""+arr[i]]==undefined){	        //将原数组每个元素作为对象在hash[]中查询
					hash[arr[i]]=1;			//若结果为undefined将元素作为新的对象进入hash[]，初始化值为1
				}else{
					hash[arr[i]]++;			//若其查询到，将hash[]中，对应对象值+1
				}
			}
			arr=[];					         //初始化数组
			for(var key in hash){
				arr.push(key-=0);		        //将对象作为值赋值给arr，(key-=0)利用隐式转化将字符串转化为数字
			}
			return arr;
		}
		del(arr);

递归算法：

基本思想：这里采用数学阶乘的来说明，6！=1*2*3*4*5*6  转化为递归思路  6！=6*(x= 5*(x= 4*(x= 3*(x= 2*(x= 1)  ) ) ) )

x的意思是分别代表下面所有式，意思是当开始的时候，6*5，发现5是一个函数，于是用X代表返回值，所以表达成6*5=6*X，X内的函数将其转化为5*4，发现4是一个函数于是转化为4*X......最后得到的方式就是：6!=6*5*4*3*2*1

                function factory(num){
		       if(num==1){       //设置最后递归结束条件
				return num;
		       }else{
				num=num*factory(num-1); //使用递归原理
				return num;
			}
		}
		x=factory(6);
		console.log(x);