前端js算法

一、关于排序

1.1冒泡排序

冒泡排序算法就是依次比较大小，小的和大的进行位置交换
（核心思想就是互换位置）

function bubbleFunc(arr){
    for(let i = 0 ;i < arr.length; i++){
       // 外层循环从下标为 0 开始 ， 内层循环从下标为 1 开始
        for(let j = i+1; j <arr.length; j++){
               if(arr[i] > arr[j]){ // 如果左边大于右边 则交换位置
                    var temp = arr[i]
                    arr[i] = arr[j]
                    arr[j] = temp   
               }
        }    
    }
   return arr
}
var bubbleList = [99, 23, 1, 33, 11, 52, 24, 10, 20, 55]
bubbleFunc(bubbleList) // 输出 [1, 10, 11, 20, 23, 24, 33, 52, 55, 99]

1.2 快速排序

取数组第一项为参照物，利用递归进行排序

算法参考某个元素值，将小于它的值，放到左数组中，大于它的值的元素就放到右数组中，然后递归进行上一次左右数组的操作，返回合并的数组就是已经排好顺序的数组了。

function quickFunc(arr){
	if(arr.length<=1){
		return arr;
	}
	var left=[],right=[],current=arr.splice(0,1);
	for(let i=0;i<arr.length;i++){
		if(arr[i]<current){
			left.push(arr[i])
		}else{
			right.push(arr[i])
		}
	}
	return quickFunc(left).concat(current,quickSort(right));
}
var quickList=[99, 23, 1, 33, 11, 52, 24, 10, 20, 55]
quickFunc(quickList) // 输出 [1, 10, 11, 20, 23, 24, 33, 52, 55, 99]

二、反向输出

2.1 数组反向输出

// 利用 数组方法  arr.reverse()
var quickList=[99, 23, 1, 33, 11, 52, 24, 10, 20, 55]
quickList.reverse() // 输出  [55, 20, 10, 24, 52, 11, 33, 1, 23, 99]

2.2 字符串反向输出

// 方法 1 结合 字符串与数组的方法
// str.split() 字符串分割成数组 ["学", "习", "前", "端", "不", "仅", "是", "为", "了", "生", "存"]
// arr.reverse() 反向排序 ["存", "生", "了", "为", "是", "仅", "不", "端", "前", "习", "学"]
// arr.join() 将数组以''拼接成字符串
var str = '学习前端不仅是为了生存'
str.split('').reverse().join('')
// 输出 "存生了为是仅不端前习学"

三、数学方法

3.1 阶乘的实现

function factorialFunc(num){
    var result = 1;
    if(num < 0) return -1;
    if(num == 0 || num == 1) return 1;
    for(i=num;i>1;i--){
    	result *= i
	}
    return result;
}
factorialFunc(5) // 输出 120

3.2 生成斐波那契数列

// 方法 1 利用循环实现
function FibonacciFunc(n){
    var fibarrList = [];
    for(let i = 0; i < n; i++){
		if(i <= 1) {
            fibarrList.push(i);
        } else {
            fibarrList.push(fibarrList[i - 1] + fibarrList[i - 2])
        }
	}
    return fibarrList;
}
FibonacciFunc(10) // 输出 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]


// 方法 2 利用递归实现
function FibonacciFunc(n){
    if(n == 0)
        return 0;
    if(n == 1)
        return 1;
    if(n > 1){
        return FibonacciFunc(n-1) + FibonacciFunc(n-2);
    }
}
function fibo(len){
    var fibo = [];
    for(var i=0;i<len;i++)
        fibo.push(FibonacciFunc(i));
    return fibo;
}
FibonacciFunc(10) // 输出 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

四、回文串

let str = '上海自来水来自海上'
function palindromeFunc(str){
    return str == str.split('').reverse().join('')
}
palindromeFunc(str) // 输出 true

五、变量值互换

// 方法 1 借助一个临时变量
let a = 1, b = 2;
let temp = '';
temp = a;
a = b;
b = temp;
console.log(a,b) // 输出 2 1


// 方法 2 es6的结构方法 不借助临时变量
let s1 = 1;
let s2 = 2;
[s2, s1] = [s1, s2]
console.log(s1,  s2)  // 输出 2 1

// 方法 3 利用数组
let  x = 1, y= 2;
x = [x, y];
y = x[0];
x = x[1];
 
console.log(x,y) // 输出 2 1

六、计算出现次数

6.1 计算字符串里出现最多的字符及次数

function findMaxRepeatChar(str){
	if(str.length == 1){
        //  长度为 1 ，直接返回
		return {key:str,num:1};
	}
	let charObj = {}; // 用来存储出现的 字符 及 次数
	for(let i = 0; i< str.length; i++){
		if(!charObj[str.charAt(i)]){
 
			charObj[str.charAt(i)] = 1;
		}else{
			charObj[str.charAt(i)] += 1;
		}
	}
	let maxChar = '',maxValue =1;
	for(let k in charObj){
		if(charObj[k] >= maxValue) {
			maxChar = k;
			maxValue = charObj[k]
		}
	}
	return  {key:maxChar, num:maxValue};
}
findMaxRepeatChar('abbcccdddd') // 输出 {key: "d", num: 4}

6.2 计算数组里出现最多的元素及次数

function findMaxRepeatChar(arr){
	if(arr.length == 1){
        //  长度为 1 ，直接返回
		return {key:arr[0],num:1};  // 返回值调整
	}
	let charObj = {}; // 用来存储出现的 字符 及 次数
	for(let i = 0; i< arr.length; i++){
		if(!charObj[arr[i]]){  //  判断条件调整
			charObj[arr[i]] = 1;
		}else{
			charObj[arr[i]] += 1;
		}
	}
	let maxChar = '',maxValue =1;
	for(let k in charObj){
		if(charObj[k] >= maxValue) {
			maxChar = k;
			maxValue = charObj[k]
		}
	}
	return  {key:maxChar, num:maxValue};
}
findMaxRepeatChar(['a','b','b','c','c','c','d','d','d','d']) // 输出 {key: "d", num: 4}