};
#### 五、155.最小栈

/**
* initialize your data structure here.
*/
var MinStack = function() {
this.arr = [];
this.minarr = [Infinity];
};
/**
* @param {number} val
* @return {void}
*/
MinStack.prototype.push = function(val) {
this.arr.push(val);
this.minarr.push(Math.min(this.minarr[this.minarr.length - 1], val));
};
/**
* @return {void}
*/
MinStack.prototype.pop = function() {
this.arr.pop();
this.minarr.pop();
};
/**
* @return {number}
*/
MinStack.prototype.top = function() {
return this.arr[this.arr.length - 1];
};
/**
* @return {number}
*/
MinStack.prototype.getMin = function() {
return this.minarr[this.minarr.length - 1];
};
/**
* Your MinStack object will be instantiated and called as such:
* var obj = new MinStack()
* obj.push(val)
* obj.pop()
* var param_3 = obj.top()
* var param_4 = obj.getMin()
*/
#### 六、剑指offer 24.反转链表

/**
* @param {ListNode} head
* @return {ListNode}
*/
var reverseList = function(head) {
let prev = null;
let curr = head;
let next;
while(curr) {
next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
return prev;
};
#### 七、200.岛屿数量

/**
* @param {character[][]} grid
* @return {number}
*/
var numIslands = function(grid) {
let res = 0;
let m = grid.length;
let n = grid[0].length;
for(let i = 0; i < m; i++) {
for(let j = 0; j < n; j++){
if(grid[i][j] == “1”) {
clearone(grid, i, j, m, n);
res++;
}
}
}
return res;
};
function clearone(grid, i, j, m, n) {
if(i < 0 || j < 0 || i > m - 1 || j > n - 1 || grid[i][j] === “0”) return;
grid[i][j] = “0”;
clearone(grid, i, j + 1, m, n);
clearone(grid, i + 1, j, m, n);
clearone(grid, i, j - 1, m, n);
clearone(grid, i - 1, j, m, n);
}
#### 八、509.斐波那契数

/**
* @param {number} n
* @return {number}
*/
var fib = function(n) {
if(n === 0) return 0;
if(n === 1) return 1;
let first = 0;
let last = 1;
for(let i = 2; i <= n; i++) {
let temp = first + last;
first = last;
last = temp;
}
return last;
};
#### 九、56.合并区间

/**
* @param {number[][]} intervals
* @return {number[][]}
*/
var merge = function(intervals) {
if(intervals.length === 0) return intervals;
let res = [];
//先排序
intervals.sort((a, b) => {
return a[0] - b[0];
})
res.push(intervals[0]);
for(let i = 1; i < intervals.length; i++) {
if(intervals[i][0] > res[res.length - 1][1]) { //直接加
res.push(intervals[i]);
} else { //存在重合情况
if(intervals[i][1] > res[res.length - 1][1]) {
res[res.length - 1] = [res[res.length - 1][0], intervals[i][1]];
}
}
}
return res;
}
#### 十、剑指offer 63.股票的最大利润

/**
* @param {number[]} prices
* @return {number}
*/
var maxProfit = function(prices) {
if(prices.length <= 1) return 0;
let max = 0;
let min = prices[0];
for(let i = 1; i < prices.length; i++) {
if(prices[i] > min) {
max = Math.max(max, prices[i] - min);
}
min = Math.min(min, prices[i]);
}
return max;
};
#### 十一、54.螺旋矩阵

/**
* @param {number[][]} matrix
* @return {number[]}
*/
var spiralOrder = function(matrix) {
if(!matrix.length || !matrix[0].length) return [];
let res = [];
let rows = matrix.length, columns = matrix[0].length;
let left = 0, right = columns - 1, top = 0, bottom = rows - 1;
while(left <= right && top <= bottom) {
for(let i = left; i <= right; i++) {
res.push(matrix[top][i]);
}
for(let i = top + 1; i <= bottom; i++) {
res.push(matrix[i][right]);
}
if(left < right && top < bottom) {
for(let i = right - 1; i > left; i--) {
res.push(matrix[bottom][i]);
}
for(let i = bottom; i > top; i--) {
res.push(matrix[i][left]);
}
}
[left, right, top, bottom] = [left + 1, right - 1, top + 1, bottom - 1];
}
return res;
};
#### 十二、94.二叉树的中序遍历

递归做法:
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val=undefined ? 0 : val)
* this.left = (left=undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var inorderTraversal = function(root) {
if(root === null) return [];
let res = [];
function inorder(node) {
if(node === null) return;
inorder(node.left);
res.push(node.val);
inorder(node.right);
}
inorder(root);
return res;
};
迭代做法:
var inorderTraversal = function(root) {
let res = [];
let stack = [];
while(root || stack.length) {
while(root) {
stack.push(root);
root = root.left;
}
root = stack.pop();
res.push(root.val);
root = root.right;
}
return res;
};
如果没有给数据结构,自己这样写:
//定义树
function TreeNode(val, left, right) {
this.val = (val === undefined ? 0 : val);
this.left = (left === undefined ? null : left);
this.right = (right === undefined ? null : right);
}
//实现中序遍历 使用迭代的方法
function inorderTraversal(root) {
let res = [];
let stack = [];
while (root || stack.length) {
while (root) {
stack.push(root);
文末
篇幅有限没有列举更多的前端面试题,小编把整理的前端大厂面试题PDF分享出来,一共有269页