前端基础算法

1.剑指 Offer 03. 数组中重复的数字
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：
输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 

答案解析1：
/**
 * @param {number[]} nums
 * @return {number}
 */
var findRepeatNumber = function(nums) {
	 let map = new Map();
	  for(let i = 0;i < nums.length;i ++){
	      if(map.has(nums[i])) return nums[i];
	      else map.set(nums[i],i);
	  }
	  return null
}

答案解析2：
var findRepeatNumber = function(nums) {
	 let res = [];
    for(let i = 0; i < nums.length;i ++){
        if(res.includes(nums[i])) return nums[i];
        else res.push(nums[i]);
    }
    return null;
}

2.剑指 Offer 04. 二维数组中的查找
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：
[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。

/**
 * @param {number[][]} matrix
 * @param {number} target
 * @return {boolean}
 */
var findNumberIn2DArray = function(matrix, target) {
  // 从右上角开始找 使用有序性
  // 长度不存在直接返回false
  if(!matrix.length) return false;

  //长度存在
  let i = 0;
  let j = matrix[0].length - 1; 

  while(i < matrix.length && j >= 0){
      // 如果值>target的值 那么往左边找
      if(matrix[i][j] > target){
          j--;
      }else if(matrix[i][j] < target){
          //往下找
          i++;
      }else{
          // 找到了
          return true;
      }
  }

  // 循环结束没找到
  return false;
};

3.剑指 Offer 05. 替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * @param {string} s
 * @return {string}
 */
var replaceSpace = function(s) {
   if(!s) return ""
   let str = s.replace(new RegExp(" ", "g"),'%20');
   return str;
};

4.剑指 Offer 06. 从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {number[]}
 */
var reversePrint = function(head) {
   const arr = [];
   while(head){
       arr.unshift(head.val);
       head = head.next
   }

   return arr;
};

5.剑指 Offer 09. 用两个栈实现队列
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
示例 1：

输入：
[“CQueue”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
[“CQueue”,“deleteHead”,“appendTail”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

//分析：
//栈:1 2 3 => 3 2 1 后进先出 LIFO
//队列: 1 2 3 => 1 2 3 先进先出FIFO
//如何实现?两个栈 2次翻转实现
//1 2 3 => 3 2 1 => 1 2 3

var CQueue = function() {
    //初始化2个栈
    //js的队列和栈都数组
    this.stk1 = [];
    this.stk2 = [];
};

/** 
 * @param {number} value
 * @return {void}
 */
CQueue.prototype.appendTail = function(value) {
    //添加一个元素 直接在栈中添加
    this.stk2.push(value)
};

/**
 * @return {number}
 */
CQueue.prototype.deleteHead = function() {
    //返回队头
    if(!this.stk2.length) return -1;
    //不为空
    while(this.stk2.length){
        //使用辅助栈
        this.stk1.push(this.stk2.pop());
    }
    let head = this.stk1.pop();
    while(this.stk1.length){
        this.stk2.push(this.stk1.pop());//将辅助线数据归还
    }
    return head;//最后返回队头
};

/**
 * Your CQueue object will be instantiated and called as such:
 * var obj = new CQueue()
 * obj.appendTail(value)
 * var param_2 = obj.deleteHead()
 */

6.剑指 Offer 10- I. 斐波那契数列
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：1
示例 2：
输入：n = 5
输出：5

/**
 * @param {number} n
 * @return {number}
 */

var fib = function(n) {
   let a = 0;
   let b = 1;
   let sum = 0;
   for(let i = 0; i < n;i ++){
       sum = (a+b) % 1000000007;
       a = b;
       b = sum;
   }
   return a;
};

7.剑指 Offer 07. 重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。
假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]
示例 2:
Input: preorder = [-1], inorder = [-1]
Output: [-1]

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = function(preorder, inorder) {
    if(!preorder.length || !inorder.length) return null;

    //找到根节点
    let root = preorder[0];
    let rootNode = new TreeNode(root);
    
    let i = 0;
    for(;i < inorder.length; i ++){
        if(inorder[i] === root){
            break;
        }
    }

    //开始递归 参数[前序][中序]
    rootNode.left = buildTree(preorder.slice(1,i+1),inorder.slice(0,i));
    rootNode.right = buildTree(preorder.slice(i+1),inorder.slice(i+1));
    return rootNode;
};