阅读 230

微信社招算法面经

楼主于数个月前面了wxg,前前后后3、4面,几乎每一面都有算法,哈哈哈,不愧是微信事业群,狠重视算法,结果蛮遗憾的,没有能走到GM面[哭的很大声]。 但整个过程下来,还是蛮有收获的。一方面自己对于数据结构有了更深的理解,一方面也对认识了自己的不足。在此也感谢给予我帮助的大佬。再接再厉,下次再战。

以下是一些记录。

一、有印象的几道算法题如下:

1、实现二叉树镜像(翻转)

function treeFun(root) {
  if (root === null) return null;
  function treeList(node) {
    let left = node.left;
    let right = node.right;
    node.left = right;
    node.right = left;
  }
  // 前序遍历 || 后序遍历
  treeFun(root);
  treeList(root.left);
  treeList(root.right);
  return root;
}
复制代码

2、使用非递归的方式实现二叉树前序遍历

// 前序遍历
const preorderTraversal = (root) => {
    const list = [];
    const stack = [];
    if(root) stack.push(root)
    while(stack.length > 0) {
        const curNode = stack.pop()
        list.push(curNode.val)
        if(curNode.right !== null) {
            stack.push(curNode.right)
        }
        if(curNode.left !== null) {
            stack.push(curNode.left)
        }
    }
    return list
}
复制代码

3、字符串转整形

let strToNumberFun = function (str) {
  let res = parseInt(str); // 如果遇到不能转数字的,则为NAN
  let max = Math.pow(2, 31);
  let min = Math.pow(-2, 31);
  if (isNaN(res)) {
    return 0;
  } else if (res > max) {
    return max;
  } else if (res < min) {
    return min;
  } else {
    return res;
  }
};
复制代码

还有没有其他的解法? 另外一种解法是使用正则,有兴趣的同学可以试试。

4、找出数组中的质数

// 省略
复制代码

5、写一个快排

function quickArrFun(arr) {
  let leng = arr.length;
  if (leng === 1) return arr;
  let quick = arr[0];
  let left = [],
    right = [],
    res = [];
  for (let i = 1; i < leng; i++) {
    if (quick < arr[i]) right.push(arr[i]);
    if (quick > arr[i]) left.push(arr[i]);
  }
  res = [...quickArrFun(left), quick, ...quickArrFun(right)];
  return res;
}
复制代码

6、实现一个apply

Function.prototype.apply = function (context, arr) {
    var context = Object(context) || window;
    context.fn = this;

    var result;
    if (!arr) {
        result = context.fn();
    }
    else {
        var args = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            args.push('arr[' + i + ']');
        }
        result = eval('context.fn(' + args + ')')
    }

    delete context.fn
    return result;
}
复制代码

其他的就不一一列举了...

二、以下是自己复习到的部分算法:

1、二叉树

/*二叉树 start*/
function treeFun(root) {
  if (root === null) return null;
  let temp = root.left;
  root.left = root.right;
  root.right = temp;
  treeFun(root.left);
  treeFun(root.right);
}

// 二叉树中序遍历
function treeFunMid(root) {
  let result = [];
  var inorderTraversal = (node) => {
    if (node) {
      // 先遍历左子树
      inorderTraversal(node.left);
      // 再根节点
      result.push(node.val);
      // 最后遍历右子树
      inorderTraversal(node.right);
    }
  };
  inorderTraversal(root);
  return result;
}

const inorderTraversal = (root) => {
  let list = [];
  let stack = [];
  let node = root;

  while (node || stack.length) {
    // 遍历左子树
    while (node) {
      stack.push(node);
      node = node.left;
    }

    node = stack.pop();
    list.push(node.val);
    node = node.right;
  }
  return list;
};

var inorderTraversal = function (root) {
  if (root === null) return [];
  let stack = [root]; // 利用栈来遍历树
  let res = [];
  while (stack.length) {
    let current = stack.pop();
    if (current === null) continue;
    if (!current.visited) {
      // 节点未被访问
      current.visited = true; // 设置了一个变量,标记该节点是否被访问了
      stack.push(current.right, current, current.left); // 不管三七二十一,按照右根左的顺序全部入栈,即使有null的也会在上面continue的时候跳过
    } else {
      // 节点已经被访问了,输出值,遍历栈里的下一个节点
      res.push(current.val);
    }
  }
  return res;
};

// 二叉树的第k大节点
function treeKFun(root, k) {
  if (root === null) return null;
  let res = [];
  function treeNode(node) {
    treeNode(node.left);
    res.push(node.val);
    treeNode(node.right);
  }
  treeNode(root);
  return res[res.length - k];
}

/*二叉树 end*/
复制代码

2、排序

/*排序 start*/

// 冒泡排序
function arrFun(arr) {
  let leng = arr.length;
  if (leng === 1) return arr;
  for (let i = 0; i < leng; i++) {
    for (let j = i + 1; j < leng; j++) {
      if (arr[i] > arr[j]) {
        let temp = arr[j];
        arr[i] = temp;
        arr[j] = arr[i];
      }
    }
  }
  return arr;
}

// 选择排序
function arrSelectFun(arr) {
  let leng = arr.length;
  if (leng === 1) return arr;
  for (let i = 0; i < leng; i++) {
    let mix = i;
    for (let j = i + 1; j < leng; j++) {
      if (arr[mix] > arr[j]) {
        mix = j;
      }
      let temp = arr[i];
      arr[i] = arr[mix];
      arr[mix] = temp;
    }
  }
  return arr;
}

// 快速排序
function quickArrFun(arr) {
  let leng = arr.length;
  if (leng === 1) return arr;
  let quick = arr[0];
  let left = [],
    right = [],
    res = [];
  for (let i = 1; i < leng; i++) {
    if (quick < arr[i]) right.push(arr[i]);
    if (quick > arr[i]) left.push(arr[i]);
  }
  res = [...quickArrFun(left), quick, ...quickArrFun(right)];
  return res;
}

/*排序 end*/
复制代码

3、LeetCode 相关

/*LeetCode start*/

// leetcode 88、合并两个有序数组
/*输入:
  nums1 = [1,2,3,0,0,0], m = 3
  nums2 = [2,5,6],       n = 3
  输出: [1,2,2,3,5,6]
*/
function concactArrFun(nums1, m, nums2, n) {
  nums1.splice(m, n, ...nums2);
  nums1.sort((a, b) => {
    a - b;
  });
  return nums1;
}

// leetcode415 字符串相加
/*给定两个字符串形式的非负整数 num1 和 num2 ,计算它们的和。例如:"111" + ”2222“ = ”2333“*/

function addStringFun(num1, num2) {
  let result = '';
  let temp = 0;
  let arr1 = num1.splice('');
  let arr2 = num2.splice('');
  while (arr1.length || arr2.length || temp) {
    temp += ~~arr1.pop() + ~~arr2.pop();
    result = (temp % 10) + result;
    temp = ~~(result / 10);
  }
  return result.replace(/^0+/, '');
}

// 腾讯&leetcode43:字符串相乘
/* 给定两个以字符串形式表示的非负整数 num1 和 num2,返回 num1 和 num2 的乘积,它们的乘积也表示为字符串形式。
  示例 1:
  输入: num1 = "2", num2 = "3"
  输出: "6"
  示例 2:
  输入: num1 = "123", num2 = "456"
  输出: "56088" 
  */
function stringMultiply(num1, num2) {
  let result = 0;
  let temp = 0;
  let arr1 = num2.splice('');
  while (arr1.length) {
    result += ~~num1 * ~~arr1.pop() * factorial(temp);
    temp += 1;
  }
  function factorial(n) {
    if (n === 0) return 1;
    return 10 * factorial(n - 1);
  }
  return result;
}

// 5. 最长回文子串 leetcode
var longestPalindrome = function (s) {
  if (s.length < 2) {
    return s;
  }
  let res = '';
  for (let i = 0; i < s.length; i++) {
    // 回文子串长度是奇数
    helper(i, i);
    // 回文子串长度是偶数
    helper(i, i + 1);
  }

  function helper(m, n) {
    while (m >= 0 && n < s.length && s[m] == s[n]) {
      m--;
      n++;
    }
    // 注意此处m,n的值循环完后  是恰好不满足循环条件的时刻
    // 此时m到n的距离为n-m+1,但是mn两个边界不能取 所以应该取m+1到n-1的区间  长度是n-m-1
    if (n - m - 1 > res.length) {
      // slice也要取[m+1,n-1]这个区间
      res = s.slice(m + 1, n);
    }
  }
  return res;
};
console.log(longestPalindrome('asdasddsadfg'));

/* 腾讯&leetcode647:回文子串 #107
      给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。
      具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被视作不同的子串。
      示例 1:
      输入:"abc"
      输出:3
      解释:三个回文子串: "a", "b", "c"
      示例 2:
      输入:"aaa"
      输出:6
      解释:6个回文子串: "a", "a", "a", "aa", "aa", "aaa"
*/

// 暴力拆解
function backStringFun(str) {
  let count = 0;
  let leng = str.length;
  for (let i = 0; i < leng; i++) {
    for (let j = i; j < leng; j++) {
      if (addFun(str.substring(i, j + 1))) {
        count++;
      }
    }
  }
  function addFun(res) {
    let i = 0,
      j = res.length - 1;
    while (i < j) {
      if (res[i] != s[j]) return false;
      i++;
      j--;
    }
    return true;
  }
}

/*寻找两个正序数组的中位数
      https://github.com/sisterAn/JavaScript-Algorithms/issues/162
      */
const arr1 = [1, 2, 10];
const arr2 = [2, 5, 7, 8];

function findMiddleNumber(arr1, arr2) {
  // 容错处理
  if (!arr1.length && !arr2.length) return null;
  // 合并并排序
  const total = [...arr1, ...arr2].sort((a, b) => a - b);
  // 中位数索引
  let midIndex = (total.length - 1) / 2;

  // 两位
  if (String(midIndex).includes('.')) {
    const left = parseInt(midIndex);
    const right = parseInt(midIndex) + 1;
    const midNumber = (total[left] + total[right]) / 2;
    return midNumber.toFixed(5);
  } else {
    // 一位
    return total[midIndex].toFixed(5);
  }
}

console.log(findMiddleNumber(arr1, arr2));

/*
      const arr = [101,19,12,51,32,7,103,8];
      问题一: 找出连续最大升序的数量
      问题二: 找出不连续最大升序的数量
      */

const findLengthOfLCIS = (nums) => {
  if (nums.length <= 1) return nums.length;
  let max = 1,
    count = 1;
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] > nums[i - 1]) {
      count += 1;
    } else {
      count = 1;
    }
    max = Math.max(max, count);
  }
  return max;
};

function queryFn(arr) {
  if (!arr.length) return 0;
  let res = 1;
  let num = 0;
  let lastVal = 0;
  for (let i = 0, len = arr.length - 1; i < len; i++) {
    for (let j = i + 1; j < len; j++) {
      if (arr[j] > lastVal) {
        num++;
        lastVal = arr[j];
      }
    }
    res = Math.max(res, num);
  }
  return res;
}

/*接雨水 https://github.com/sisterAn/JavaScript-Algorithms/issues/122
      给定 n 个非负整数表示每个宽度为 1 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。
      示例 1:
      输入:height = [0,1,0,2,1,0,1,3,2,1,2,1]
      输出:6
      解释:上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)
。*/
// 双指针
function trap(height) {
  let total = 0;
  let left = 0,
    right = height.length - 1,
    leftMax = 0,
    rightMax = 0;
  while (left <= right) {
    leftMax = Math.max(leftMax, height[left]);
    rightMax = Math.max(rightMax, height[right]);
    if (leftMax < rightMax) {
      total += leftMax - height[left];
      left++;
    } else {
      total += rightMax - height[right];
      right--;
    }
  }
  return total;
}

/*LeetCode end*/
复制代码

4、链表

/*链表 start*/
/* leetcode 19. 给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
        进阶:你能尝试使用一趟扫描实现吗?
        示例 1:
        输入:head = [1,2,3,4,5], n = 2
        输出:[1,2,3,5]
*/
/**
  * Definition for singly-linked list.
  * function ListNode(val, next) {
  *     this.val = (val===undefined ? 0 : val)
  *     this.next = (next===undefined ? null : next)
  * }
  */
/**
  * @param {ListNode} head
  * @param {number} n
  * @return {ListNode}
  */
var removeNthFromEnd = function (head, n) {
  var ret = new ListNode(0, head);
  var slow = (fast = ret);
  while (n--) {
    fast = fast.next;
  }
  if (!fast) return ret.next;
  while (fast.next) {
    fast = fast.next;
    slow = slow.next;
  }
  slow.next = slow.next.next;
  return ret;
};

// leetcode024. `反转链表`
/*
输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]
*/
/**
  * Definition for singly-linked list.
  * function ListNode(val, next) {
  *     this.val = (val===undefined ? 0 : val)
  *     this.next = (next===undefined ? null : next)
  * }
  */
/**
  * @param {ListNode} head
  * @return {ListNode}
  */
var reverseList = function (head) {
  if (!head || !head.next) return head;
  let temp = null,
    pre = null,
    cur = head;
  while (cur) {
    temp = cur.next;
    cur.next = pre;
    pre = cur;
    cur = temp;
  }
  // temp = cur = null;
  return pre;
};
/*链表 end*/
复制代码
文章分类
前端
文章标签