算法笔记（更新中...）

var CQueue = function () {
  this.inStatck = [];
  this.outStack = [];
};

/**
 * @param {number} value
 * @return {void}
 */
CQueue.prototype.appendTail = function (value) {
  this.inStatck.push(value);
};

/**
 * @return {number}
 */
CQueue.prototype.deleteHead = function () {
  if (!this.outStack.length) {
    if (!this.inStatck.length) {
      return -1;
    }
    this.reserveStack();
  }

  return this.outStack.pop();
};

CQueue.prototype.reserveStack = function () {
  while (this.inStatck.length) {
    this.outStack.push(this.inStatck.pop());
  }
};
/**
 * Your CQueue object will be instantiated and called as such:
 * var obj = new CQueue()
 * obj.appendTail(value)
 * var param_2 = obj.deleteHead()
 */

/**
 * @param {number[][]} matrix
 * @param {number} target
 * @return {boolean}
 */
var findNumberIn2DArray = function (matrix, target) {
  if (!matrix.length) return false;
  let i = matrix.length - 1;
  let j = 0;
  while (i >= 0 && j < matrix[0].length) {
    if (matrix[i][j] < target) {
      j++;
    } else if (matrix[i][j] > target) {
      i--;
    } else {
      return true;
    }
  }
  return false;
};

var levelOrder = function (root) {
  let queue = [];
  let res = [];
  if (!root) {
    return res;
  }
  queue.push(root);
  if (queue.length !== 0) {
    let len = queue.length;
    res.push([]);
    for (let i = 0; i < len; i++) {
      let node = queue.shift();
      res[res.length - 1].push(node.val);
      if (node.left) {
        queue.push(node.left);
      }
      if (node.right) {
        queue.push(node.right);
      }
    }
  }
  return res;
};

/**
 * @param {number[]} nums
 * @return {string}
 */
var minNumber = function (nums) {
  nums = nums.sort((a, b) => {
    return "" + a + b - ("" + b + a);
  });
  return nums.join("");
};

/**
 * @param {number} n
 * @return {number}
 */
var numWays = function (n) {
  if (n == 0 || n == 1) {
    return 1;
  }

  let f1 = 1;
  let f2 = 1;
  let f3 = 0;
  for (let i = 2; i <= n; i++) {
    f3 = (f1 + f2) % 1000000007;
    f1 = f2;
    f2 = f3;
    if (i === n) {
      return f3;
    }
  }
};

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function (prices) {
  let max = 0;
  for (let i = 0; i < prices.length; i++) {
    for (let j = i + 1; j < prices.length; j++) {
      let profit = prices[j] - prices[i];
      if (profit > max) {
        max = profit;
      }
    }
  }
  return max;
};

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function (prices) {
  let max = 0;
  let minPrice = Number.MAX_VALUE;
  for (let price of prices) {
    max = Math.max(max, price - minPrice);
    minPrice = Math.min(price, minPrice);
  }
  return max;
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function (nums) {
  let leftMax = nums[0];
  let max = nums[0];
  for (let i = 1; i < nums.length; i++) {
    leftMax = Math.max(nums[i], leftMax + nums[i]);
    max = leftMax > max ? leftMax : max;
  }
  return max;
};