LeetCode剑指offer记录（1）
LeetCode剑指offer记录
第一天
01.01
实现一个算法，确定一个字符串 s 的所有字符是否全都不同。
示例 1：
输入: s = "leetcode"
输出: false
示例 2：
输入: s = "abc"
输出: true
限制：
0 <= len(s) <= 100
如果你不使用额外的数据结构，会很加分。
利用对象作哈希表。
/**
* @param {string} astr
* @return {boolean}
*/
var isUnique = function(astr) {
const obj = {}
for (var i = 0; i < astr.length; i++) {
if (obj[astr[i]]) {
return false
}
obj[astr[i]] = 1
}
return true
}
01.03
找出数组中重复的数字。
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
示例 1：
输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3
限制：
2 <= n <= 100000
利用对象作哈希表
/**
* @param {number[]} nums
* @return {number}
*/
var findRepeatNumber = function(nums) {
var obj1 = {}
for (var i = 0; i < nums.length; i++) {
if (obj1[nums[i]] == 1) {
return nums[i]
}
obj1[nums[i]] = 1
}
}
01.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。
限制：
0 <= n <= 1000
0 <= m <= 1000
从左下角元素开始往上遍历，如果该元素比target大，则target不可能在这一行。如果该元素比target小，则利用[].includes()遍历该行元素。
/**
* @param {number[][]} matrix
* @param {number} target
* @return {boolean}
*/
var findNumberIn2DArray = function(matrix, target) {
var n = matrix.length //行数
// var m = matrix[0].length //列数
for (var i = n - 1; i >= 0; i--) {
if (matrix[i][0] <= target)
if (matrix[i].includes(target) != 0) {
return true
}
}
return false
}
01.05
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：
输入：s = "We are happy."
输出："We%20are%20happy."
限制：
0 <= s 的长度 <= 10000
利用正则。
/**
* @param {string} s
* @return {string}
*/
var replaceSpace = function(s) {
return s.replace(/ /g, "%20");
};
01.06
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000
先将链表每一个节点的值传入数组，最后利用[].reverse()反转数组即可
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @return {number[]}
*/
var reversePrint = function(head) {
var currNode = head
var arr = []
while (currNode != null) {
arr.push(currNode.val)
currNode = currNode.next
}
return arr.reverse()
}
第二天
01.07
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/
9 20
/
15 7
限制：
0 <= 节点个数 <= 5000
利用分治法，前序遍历第一个数必定是根节点，根据根节点来到中序遍历，中序遍历中根节点左边是左子树，右边是右子树。
最后利用递归即可。
/**
* 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 == 0 || inorder.length == 0) {
return null
}
var root = preorder[0]
var currNode = new TreeNode(root)
var i = 0
for (; i < inorder.length; i++) {
if (inorder[i] == root) {
break
}
}
//splice会使数组本身发生变化。
currNode.left = buildTree(preorder.slice(1, i + 1), inorder.slice(0, i))
currNode.right = buildTree(preorder.slice(i + 1), inorder.slice(i + 1))
return currNode
}
01.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 <= values <= 10000
最多会对 appendTail、deleteHead 进行 10000 次调用
栈的特性是：后入先出。根据题目提示，使用 2 个栈即可。
一个栈inStack用来存储插入队列的数据，一个栈outStack用来从队列中取出数据。
算法分为入队和出队过程。
入队过程：将元素放入 inStack 中。
出队过程：
outStack 不为空：弹出元素
outStack 为空：将 inStack 元素依次弹出，放入到 outStack 中（在数据转移过程中，顺序已经从后入先出变成了先入先出）
var CQueue = function() {
this.inStack = []
this.outStack = []
}
/**
* @param {number} value
* @return {void}
*/
CQueue.prototype.appendTail = function(value) {
this.inStack.push(value)
return null
}
/**
* @return {number}
*/
CQueue.prototype.deleteHead = function() {
if (this.outStack.length) {
return this.outStack.pop()
} else {
while (this.inStack.length) {
var a = this.inStack.pop()
this.outStack.push(a)
}
}
return this.outStack.length ? this.outStack.pop() : -1
}
/**
* Your CQueue object will be instantiated and called as such:
* var obj = new CQueue()
* obj.appendTail(value)
* var param_2 = obj.deleteHead()
*/
01.10-1
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 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
提示：
0 <= n <= 100
/**
* @param {number} n
* @return {number}
*/
var fib = function(n) {
if(n===0){return 0}
if(n===1){return 1}
let a=0n;
let b=1n;
var c=0
for(var i=2;i<=n;i++)
{
c=a+b
a=b
b=c
}
return c%1000000007n
};
01.10-2
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：2
示例 2：
输入：n = 7
输出：21
提示：
0 <= n <= 100
/**
* @param {number} n
* @return {number}
*/
var numWays = function(n) {
if (n === 0) {
return 1
}
if (n === 1) {
return 1
}
if (n === 2) {
return 2
}
let a = 1n
let b = 2n
var c = 0n
for (var i = 3; i <= n; i++) {
c = a + b
a = b
b = c
}
return c % 1000000007n
}
01.11
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
示例 1：
输入：[3,4,5,1,2]
输出：1
示例 2：
输入：[2,2,2,0,1]
输出：0
二分法。以中间位置为界，分为左右两个子数组。中间元素被包含在左边。
①如果最右边元素比中间元素大，则右子数组一定是递增的。所以最小值一定在左子数组。
②如果最右边元素比中间元素小，则最小值一定在右子数组。
③如果最右边元素同中间元素相等。则舍去最右边的元素去重。
/**
* @param {number[]} numbers
* @return {number}
*/
var minArray = function(numbers) {
let left = 0
let right = numbers.length - 1
while (left <= right) {
let mid = Math.floor((right + left) / 2)
if (numbers[mid] < numbers[right]) {
right = mid
} else if (numbers[mid] > numbers[right]) {
left = mid + 1
}
//如果中间和右边相同时，去重
else {
right--
}
}
return numbers[left]
}
01.12
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。
[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]
但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。
示例 1：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：
输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false
提示：
1 <= board.length <= 200
1 <= board[i].length <= 200
DFS深度优先算法和回朔法的运用。
exist函数遍历二维数组board，如果找到与word[0]相同的元素，则运行fun1函数。找不到则返回false。
fun1负责接收exist函数传入的顶点位置row,col 并进行深度优先搜索。由空对象visited记录已走过的点。
/**
* @param {character[][]} board
* @param {string} word
* @param {number} row
* @param {number} col
* @param {object} visited
* @return {boolean}
*/
var fun1 = function(board, word, row, col, visited) {
if (!word.length) {
return true
}
var key = `${row},${col}`
if (
row >= board.length ||
row < 0 ||
col >= board[0].length ||
col < 0 ||
visited[key] ||
board[row][col] !== word[0]
) {
return false
}
visited[key] = true
word = word.substring(1)
//进行下一步寻路，无所谓顺序。
let success =
fun1(board, word, row + 1, col, visited) ||
fun1(board, word, row - 1, col, visited) ||
fun1(board, word, row, col + 1, visited) ||
fun1(board, word, row, col - 1, visited)
visited[key] = success//此时如果success==false，则回溯了
return success
}
/**
* @param {character[][]} board
* @param {string} word
* @return {boolean}
*/
var exist = function(board, word) {
var rowNum = board.length
var colNum = board[0].length
for (var i = 0; i < rowNum; i++) {
for (var j = 0; j < colNum; j++) {
if (board[i][j] === word[0]) {
var isExist = fun1(board, word, i, j, {})
if (isExist) {
return true
}
//else {
// return false
// }这里不能退出 因为可能存在多个与word[0]相同的实例。
}
}
}
return false
}
浙公网安备 33010602011771号