前端面试算法-高频

反转链表

输入：{1,2,3}
返回值：{3,2,1}

function ReverseList(pHead)
{
    let nex = null, cur=pHead, pre = null;
    while(cur) {
        nex = cur.next;
        cur.next = pre;
        pre = cur;
        cur = nex;
    }
    return pre
}

排序数组

//1.大顶堆
var bigHeap = (arr) => {
  //1.构建大顶堆
  for(let i = parseInt(arr.length/2-1); i>=0;i--){
    adjustHeap(arr,i,arr.length)// //从第一个非叶子结点从下至上，从右至左调整结构
  }
  // 上述逻辑，建堆结束下面，开始排序逻辑
  for(let j=arr.length-1;j>0;j--) {
    // 元素交换,作用是去掉大顶堆
    // 把大顶堆的根元素，放到数组的最后；换句话说，就是每一次的堆调整之后，都会有一个元素到达自己的最终位置
    swap(arr, 0, j);//将堆顶元素与末尾元素进行交换.毫无疑问，最后一个元素无需再考虑排序问题了
    adjustHeap(arr, 0, j)
  }
  return arr

}

var adjustHeap = (arr, i, len) => {
  // 先把当前元素取出来，因为当前元素可能要一直移动
  let tmp = arr[i];
  for(let k=2*i+1; k<len; k=2*k+1) { //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
    if(k+1<len && arr[k] < arr[k+1]) {//如果左子结点小于右子结点，k指向右子结点
      k++;
    }
    if(arr[k] > tmp) {//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
      arr[i] = arr[k];
      i=k;
    } else{
      break;
    }
  }
  arr[i] = tmp;//将temp值放到最终的位置
}
var swap = (arr, a, b) => {
  let tmp = arr[a];
  arr[a] = arr[b];
  arr[b] = tmp;
}

2.快排序
function quickSort(arr) {
    if (arr.length <= 1) return arr
    let pivotIndex = Math.floor(arr.length / 2)
    const pivot = arr[pivotIndex]
    const left = [], right = []
    for (let i = 0; i < arr.length; i++) {
        if (i === pivotIndex) continue
        if (arr[i] <= pivot) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return quickSort(left).concat(pivot).concat(quickSort(right))
}

数组去重

//注意{} != {}   NaN != NaN
Array.prototype.uniq = function () {
    //return [...new Set(this)]
    let ans = [],flag = true;
    for(let i=0;i<this.length;i++){
        if(ans.indexOf(this[i]) === -1) {
            if(this[i] != this[i] && (typeof this[i] === 'number')) { //NaN
                if(flag) {
                    ans.push(this[i]);
                    flag = false;
                }
            } else{
                ans.push(this[i]);
            }
        }
    }
    return ans
}

时间格式化

输入：formatDate(new Date(1409894060000), ‘yyyy-MM-dd HH:mm:ss 星期w’)
输出：2014-09-05 13:14:20 星期五

function formatDate(time, mode) {
    let obj={};
    obj.yyyy = time.getFullYear();
    obj.yy = time.getFullYear().slice(-2);
    obj.MM = ('0'+(time.getMonth() + 1)).slice(-2);
    obj.M = time.getMonth() + 1;
    obj.dd = ('0'+time.getDate()).slice(-2);
    obj.dd = time.getDate();
    obj.HH = ('0'+time.getHours()).slice(-2);
    obj.H = time.getHours();
    obj.hh = ('0' + time.getHours()%12).slice(-2);
    obj.h = time.getHours()%12;
    obj.mm = ('0' + time.getMinutes()).slice(-2);
    obj.m = time.getMinutes();
    obj.ss = ('0' + time.getSeconds()).slice(-2);
    obj.s = time.getSeconds();
    obj.w = time.getSeconds();
    let day = ['日', '一', '二', '三', '四', '五', '六'][date.getDay()];//星期0-6，0-日
    return mode.replace(/[A-Za-z]+/g, function(str) {
                        return obj[str];
                        })
}

将字符串转为驼峰形式

‘font-size’---->fontSize

function cssStyle2DomStyle(sName) {
    let arr = sName.split('')
    if(arr[0]=='-') arr.splice(0,1)
    for(let i in arr){
        if(arr[i] == '-'){
            arr.splice(i,1)
            arr[i] = arr[i].toUpperCase()
        }
        
    }
    let str = arr.join('')
    return str
}

函数柯里化

柯里化是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。

function curryIt(fn) {
	var length = fn.length,
		args = [];
    var result =  function (arg){
        args.push(arg);
        length --;
        if(length <= 0 ){
            return fn.apply(this, args);
        } else {
            return result;
        }
    }
    
    return result;
}