一、JS算法的基础
1、数组去重
js">function qc(arr1){
//创建一个新的数组
let arr = [];
//遍历数组arr1
for( let i = 0; i < arr1.length; i++) {
//如果arr1不在arr中 会返回-1 那么将和这个元素存在新建的arr中
if( arr.indexOf(arr1[i]) == -1) {//indexOf判断arr1是否在arr数组里，没有返回-1
arr.push(arr1[i])
}
}
//返回arr
return arr;
}
arr1 = ["1","1","3","5","2","24","4","4","a","a","b"];
console.log(qc(arr1));
//输出结果["1", "3", "5", "2", "24", "4", "a", "b"]
2、冒泡排序
js">function sort(elements) {
for(var i=0;i<elements.length - 1;i++){//最后一位不需要再遍历一次，所以-1
for (var j=0;j<elements.length-i-1;j++){//减i表示从第i个开始，减1同上
//两个for循环 依次比较 把较大的数记录下来给后面 依次类推 达到排序的结果
if(elements[j]>elements[j+1]){
var swap = elements[j];
elements[j]=elements[j+1];
elements[j+1]=swap;
}
}
}
return elements;
}
var elements = [3,1,5,9,6];
console.log(sort(elements));
//输出结果[1, 3, 5, 6, 9]
3、快速排序
js">var quicksort = function(arr){
if(arr.length<=1){
return arr;
}
//取中间值作为一个标杆进行比较
var midIndex=Math.floor(arr.length/2);
var midIndexVal=arr.splice(midIndex,1);//取到中间值
//新建两个数组存放比中间值大的或者小的
var left=[];
var right=[];
for(var i=0;i<arr.length;i++){
if(arr[i]<midIndexVal){
//如果比中间值小放在左面
left.push(arr[i]);
}else{
//如果比中间值大放在右面
right.push(arr[i]);
}
}
//依次将两边的数组在调用quicksort函数最后进行concat连接数组
return quicksort(left).concat(midIndexVal,quicksort(right));
}
var b = [1,6,2,8,4,3,70,50,30]
console.log(quicksort(b));
//[1, 2, 3, 4, 6, 8, 30, 50, 70]
4、递归
js">//阶乘算法
function jiecheng(num){
if (num == 1){
return 1;
}
return num*jiecheng(num-1);//5*4*3*2
}
console.log(jiecheng(5))
//斐波拉契题 1， 1， 2， 3， 5， 8， 13， 21 。。。
function fei(num) {
if(num==0||num==1){
return 1;
}
return fei(num-1)+fei(num-2);
}
console.log(fei(5))
二、进阶算法
1、数组输出A[i]*i
js">function accum(str){
let result =[]
for(let i=0;i<str.length;i++){
let Letter = str.charAt(i) //把字符串弄成一个一个字
let temp = ''
for(let j=0;j<i;j++){
temp += Letter.toLowerCase()
}
result.push(Letter.toUpperCase() + temp)
}
return result.join('-')
}
console.log(accum("abcdg"));
//输出：A-Bb-Ccc-Dddd-Ggggg
2、二进制求1有多少个
js">//写一个函数bit_count返回一个数字中所有二进制位的和。 比如说1234的二进制表示是10011010010，总共有5个1，那么和是5。
function bit_count(n){
let c = 0;
do{
c+=n&1
// >>是[移位运算符]比如 3>>1 就是将3的二进制向右移移位： 11（3的二进制）
// 向右移移位变成1，低位自动消失。
}while(n >>= 1)
return c
}
var a=1234;
console.log(a.toString(2)); //把1234转成二进制
//10011010010
console.log(bit_count(a));
//5
3、快速求最大值最小值
js">var highandlow = function(arr){
//先将数组转变成字符串join()
var str = arr.join();
//eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。
var max = eval('Math.max('+str+')');
var min = eval('Math.min('+str+')');
console.log("最大值："+max+'\n'+"最小值："+min+"")
}
var mm=[10,20,50,100,500,20];
highandlow(mm);
//最大值：500 最小值：10
4、reduce累加器
js">//reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
function sum(A) {
return A.reduce((x,y)=>x+y,0)
}
var A=[1,2,3,4,5]
console.log(sum(A))
//15
5、快速反转
js">//原理求出中心值 然后进行对调
function reverse(arr){
let num=parseInt(arr.length/2);
for(var i=0;i<num;i++){
let temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
return arr;
}
var A=[1,10,5,13,26,50,2];
console.log(reverse(A))// [2, 50, 26, 13, 5, 10, 1]
6、数组旋转
js">//定义数组的旋转操作rotate(A, amount)，让数尾部amount个元素移动到头部。
//例如数组: A=[1,2,3,4,5,6,7]
//rotate(A, 1) // [7,1,2,3,4,5,6]
//rotate(A, 2) // [6,7,1,2,3,4,5]
//rotate(A, 3) // [5,6,7,1,2,3,4]
function rotate(A, amount){
//slice 调用 arrayObject.slice(start,end)可从已有的数组中返回选定的元素。
//
return (A.slice(-amount)).concat(A.slice(0,-amount))
}
var A = [1,2,3,4,5,6,7];
console.log(rotate(A, 5))
//[3, 4, 5, 6, 7, 1, 2]
7、二分查找
js">function bsearch(A, x) {//在A中找到x的下标，没有返回-1
let l = 0, // 查找范围左边界
r = A.length - 1, // 查找范围右边界
guess // 猜测位置
while(l <= r) {
guess = Math.floor ( (l+r)/2 )
// 循环不变试
// guess 等于 l ， r 中间位置
// l：查找范围左 r: 查找范围右
if(A[guess] === x) return guess
else if (A[guess] > x) r = guess - 1
else l = guess + 1
}
return -1
}
const A = [1,3,5,21,32,34,60]
console.log(bsearch(A, 88))
// -1
console.log(bsearch(A, 33))
// -1
console.log(bsearch(A, 32)) // 4
8、高阶函数接收
js">//curry是这样一个函数，它将一个接受多参数的函数，转换成为接收连续单参数的高阶函数（可以被连续调用）
//例如：
//function _add(a, b, c, d){
//return a + b + c + d
//}
//const add = curry(add)
//console.log( add(1) ) // 函数
//console.log( add(1)(2) ) // 函数
//console.log( add(1)(2)(3) ) // 函数
//console.log ( add(1)(2)(3)(4) ) // 10
function _add (a, b, c) {
return a + b + c
}
const curry = func => {//func是传入的函数
const g = (...allArgs) => {
//对象中的扩展运算符(...)用于取出allArgs参数对象中的所有可遍历属性
// ，拷贝到当前对象之中
// 返回函数，func.length是_add()函数的参数传入值数量，abc所以是三个
// 返回函数，allArgs.length是add()函数的参数传入数组，[1]所以是1个
// 当add()函数传入的的值长度对应了func参数时，执行函数
//对比两个函数的参数长度，达到一致后执行func函数也就是_add()函数的计算
return allArgs.length >= func.length ?
func(...allArgs) : (...args) => g(...allArgs, ...args)
}
return g
}
const add = curry(_add)
console.log( add(1) )
//(...args) => g(...allArgs, ...args)
console.log( add(1)(2) )
//(...args) => g(...allArgs, ...args)
console.log( add(1)(2)(3) )
//6
9、冒泡排序（高级）
js">function swap (A, i ,j) {
let a = A[i];
A[i] = A[j];
A[j] = a;
};
function bubble_sort(A) {
for (let i = A.length-1 ;i >= 1; i--){//从后面往前冒泡排序
for(j = 0 ;j <= i; j++){
A[j-1] > A[j] && swap (A, j-1 ,j)
}
}
}
const A = [16,5,2,3,4,9,10]
bubble_sort(A)
console.log(A)//[2, 3, 4, 5, 9, 10, 16]
10、保留前三后四位字符（手机号*格式）
js">function maskify3(cc) {
return cc.slice(0,3) + cc.slice(4, 8).replace(/./g, '*') + cc.slice(-4)
}
console.log(maskify3('12345678911'))
//123****8911
