js里一些经典的算法

//1.找出某个数字在一组数组内的存不存在 如果存在 找出他所在的索引。
function indexOf(arr,item){
var i;
if(Array.prototype.indexOf){
return arr.indexOf(item);
}else{
for(i=0;i<arr.length;i++){
if(arr[i] == item){
return i;
}
}
}

}
// console.log(indexOf([1,2,3,4,5],3));

//2.计算数组arr中所有元素的总和。
function sum(arr){
var i;
var all=0;
for(i=0;i<arr.length;i++){
all +=arr[i];
}
return all;
}

// console.log(sum([1,2,3,4]));
//3.移除数组arr中与item相等的元素 不直接修改数组arr 结果反回新的数组
function remove(arr,item){
var i;
var newarry = new Array;
for(i=0;i<arr.length;i++){
if(arr[i] !==item){
newarry.push(arr[i]);
}
}
return newarry;
cl
}
// console.log(remove([1,2,3,1,5,6],1));

//splice(index1,index2)方法， 第一个参数表示要删除的哪个 ,第二个表示删除几个.
function removeWithoutCopy(arr, item) {
for(var i=0;i<arr.length;i++){
if(arr[i] == item){
arr.splice(i,1)
i--;
}
}

return arr;
}
// console.log(removeWithoutCopy([1,2,3,2,2,2,4,5],2));
//4.把一个元素添加到一个数组内。
function append(arr,item){
var i=0;
var newArray =[];
for(i=0;i<arr.length;i++){
newArray.push(arr[i]);

}
newArray.push(item);
return newArray;
}
// console.log(append([1,2,3,4],5)); 1,2,3,4,5
//5.去掉一个数组中的最后一位元素 。
function truncate(arr) {
var lastIndex = arr.length-1;
return arr.slice(0,lastIndex);
}
//console.log(truncate([2,3,6,7,9]));
//6.在数组 arr 开头添加元素 item。

function prepend(arr,item){
return [item].concat(arr);
}
// console.log(prepend([1,2,3,4],5)); //5,1,2,3,4

//7. 删除数组arr第一个元素。

function curtail(arr){
var i = 0;
var newArray = [];
for(i=0;i<arr.length;i++){
if(arr[i] !== arr[0]){
newArray.push(arr[i]);
}
}
return newArray;
}
// console.log(curtail([1,2,3,4])); 2,3,4
//8. 合并2个数组
function concat(arr1,arr2){
return arr1.concat(arr2);
}
// console.log(concat([1,2,3],[4,5,6])); 1,2,3,4,5,6

//9.在数组 arr 的 index 处添加元素 item。
function insert(arr,item,index){
var newArr = arr.slice(0);
newArr.splice(index,0,item);
return newArr;
}
// console.log(insert([1,2,3,4],'a',2));

//10.统计数组中 某元素出现的次数.
function count(arr,item){
var index = 0;
var i =0;
for(i;i<arr.length;i++){
if(arr[i] == item){
index++;
}
}
return index;
}
// console.log(count([1,2,3,4,4,4,6],4));

//11. 找出数组 arr 中重复出现过的元素
function duplicates(arr){
//a数组用来存结果 b数组用来存arr的结果
var a=[],b=[];
var i;
for(i=0;i<arr.length;i++){
if(!b[arr[i]]){
b[arr[i]] = 1;
continue;
}
b[arr[i]]++;
}
for(i=0;i<b.length;i++){
if(b[i] > 1){
a.push(i);
}
}
return a;
}



//console.log(duplicates([1,2,2,2,2,2,4,4,5,3,4]));

//12. 求一个数组内所有元素的各个平方
function square(arr) {
var newArr =[];
var i;
for(i =0;i<arr.length;i++){
newArr.push(Math.pow(arr[i],2));
}
return newArr;
}
//console.log(square([2,3,4,5]));

//13. 查找item在一个字符串中出现的所有位置
//查找target的位置，只需要将数组arr中键值对key-value中value == target的key找出来存到新数组而已。因此，遍历arr，如果target == arr[i]，i即目标值位置，则将i加入到a数组中。
function findAllOccurrences(arr, item) {
var newArr = [];
var i
for(i=0;i<arr.length;i++){
if(arr[i] == item){
newArr.push(i);
}
}
return newArr;
}
// console.log(findAllOccurrences([1,2,3,2,3,2],2));
//1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
//2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
//3、第一个数需要立即输出

function count(start,end){
console.log(start++);
var timer = setInterval(function(){
if(start <= end){
console.log(start++);
}else{
clearInterval(timer);
}
},100);
//反一个对象
return{
cancel : function(){
clearInterval(timer);
}
};
}

//count(100,110);

// 实现 fizzBuzz 函数，参数 num 与返回值的关系如下：
//1、如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
//2、如果 num 能被 3 整除，返回字符串 fizz
//3、如果 num 能被 5 整除，返回字符串 buzz
//4、如果参数为空或者不是 Number 类型，返回 false
//5、其余情况，返回参数 num

function fizzBuzz(num) {
if(num % 3 == 0 && num % 5==0){
return 'fizzbuxz';
}else if(num % 3 ==0){
return 'fizz';
}else if(num % 5 ==0){
return 'buzz';
}else if(num ==null || typeof num !== 'number'){
return false;
}else{
return num;
}
};
//console.log(fizzBuzz(3));

function hasStr(str){
var b = /\b/;
return b.test(str);
}

// console.log(hasStr("abc123"));

//冒泡排序
/*
冒泡排序的原理是这样的，比方说有五个数字54321，要按从小到大排列；
首先比较前两个，就是5和4，如果第一个小于第二个，不做操作，如果第一个大于第二个，那么交换二者的位置，即变成45321，然后比较第二个和第三个，交换位置，变成43521，然后第三个和第四个，第四个和第五个，这样一次循环下来，变成43215
所以，一层循环的效果就是挑出最大的一个数字5，冒泡到最后面。但是还要挑出第二大，第三大的数字，等等。所以一层循环根本就不够用，必须再套一层才行。像这个例子，五个数字，起码要进行四轮循环才行。至于为什么要this.length-i，是因为第一次比较五个数字，第二个只要比较前四个就行了，第五个肯定是最大的了
*/
function maopaoSort(arr){
var temp = 0;
for (var i = 0; i < arr.length; i++){
for (var j = 0; j < arr.length - i; j++){
if (arr[j] > arr[j + 1]){
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}

//console.log(maopaoSort( [5, 4, 3, 2, 1]));

//正常排序方法 -正序
function addSortP(a,b){
return a -b;
}
function arrA(arr){
return arr.sort(addSortP);
}
console.log(arrA([1,4,5,6,2,3]));

//正常排序方法 -反序
function add(a,b){
return b-a;
}
function arrB(arr){
return arr.sort(add);
}
console.log(arrB([1,4,5,6,2,3]));