目录
使用语言: JavaScript。
从简单题开始写的，只放上了代码，没有写思路。
简单题
两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]
/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
var twoSum = function(nums, target) {
let temp = [];
for (let i = 0; i < nums.length; i++){
let diff = target - nums[i];
if (temp[diff] !== undefined) {
return [temp[diff], i];
}
temp[nums[i]] = i;
}
};
使用map
var twoSum = function(nums, target) {
let map = new Map();
for (let i = 0; i < nums.length; i++) {
let dif = target-nums[i]
if (map.has(dif)) {
return [map.get(dif), i]
}
map.set(nums[i], i);
}
};
整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1: 输入: 123 输出: 321示例 2: 输入: -123 输出: -321示例 3: 输入: 120 输出: 21注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
/**
* @param {number} x
* @return {number}
*/
var reverse = function(x) {
const res = parseInt(x.toString().split('').reverse().join(''));
if (res < -2147483648 || res > 2147483647) {
return 0
}
return x > 0 ? res : -res;
};
回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1: 输入: 121 输出: true示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。示例 3: 输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。进阶:
你能不将整数转为字符串来解决这个问题吗？
字符串反转
/**
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function(x) {
const reX = x.toString().split('').reverse().join('');
if (x.toString() !== reX) {
return false;
}
return true;
};
不用字符串
var isPalindrome = function(x) {
if (x < 0 || (x % 10 === 0 && x !== 0)) {
return false;
}
let reNum = 0;
while(x > reNum) {
reNum = reNum * 10 + x % 10;
x = parseInt(x / 10);
}
return reNum === x || parseInt(reNum / 10) === x;
};
罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
- I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
- X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
- C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1: 输入: "III" 输出: 3示例 2: 输入: "IV" 输出: 4示例 3: 输入: "IX" 输出: 9示例 4: 输入: "LVIII" 输出: 58 解释: L = 50, V= 5, III = 3.示例 5: 输入: "MCMXCIV" 输出: 1994 解释: M = 1000, CM = 900, XC = 90, IV = 4.
/**
* @param {string} s
* @return {number}
*/
var romanToInt = function(s) {
// IV 4 IX 9 XL 40 XC 90 CD 400 CM 900
let dir = {
I: 1,
V: 5,
X: 10,
L: 50,
C: 100,
D: 500,
M: 1000
};
let res = 0;
for (let i = 0; i < s.length; i++) {
const current = dir[s[i]];
const next = dir[s[i+1]];
if (next / current === 5 || next / current === 10) {
res += next - current;
i++;
} else {
res += current;
}
}
return res;
};
最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1: 输入: ["flower","flow","flight"] 输出: "fl"示例 2: 输入: ["dog","racecar","car"] 输出: "" 解释: 输入不存在公共前缀。说明:
所有输入只包含小写字母 a-z 。
/**
* @param {string[]} strs
* @return {string}
*/
var longestCommonPrefix = function(strs) {
if (strs.length === 1) {
return strs[0];
}
strs.sort((current, next) => current.length - next.length);
let publicStr = '';
for (let i = 0; i < strs.length - 1; i++) {
let current = publicStr ? publicStr : strs[i];
let next = strs[i + 1];
let currentLength = current.length;
if (current === '') {
return '';
}
while (next.indexOf(current) !== 0) {
currentLength--;
current = current.substr(0, currentLength);
if (current === '') {
return '';
}
}
publicStr = current;
}
return publicStr;
};
有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。示例 1: 输入: "()" 输出: true示例 2: 输入: "()[]{}" 输出: true示例 3: 输入: "(]" 输出: false示例 4: 输入: "([)]" 输出: false示例 5: 输入: "{[]}" 输出: true
某大佬的做法
/**
* @param {string} s
* @return {boolean}
*/
var isValid = function(s) {
while (s.includes('()') || s.includes('[]') || s.includes('{}')) {
s = s.replace('{}', '');
s = s.replace('[]', '');
s = s.replace('()', '');
}
return s === '';
};
大佬做法2
var isValid = function(s) {
const map = {
'(':')',
'[':']',
'{':'}'
};
let leftArr = [];
for (let ch of s) {
if (ch in map) {
leftArr.push(ch);
} else {
if (ch !== map[leftArr.pop()]) {
return false;
}
}
}
return !leftArr.length;
};
合并两个有序链表
将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
大佬做法-递归
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} l1
* @param {ListNode} l2
* @return {ListNode}
*/
var mergeTwoLists = function(l1, l2) {
if (l1 === null) {
return l2;
}
if (l2 === null) {
return l1;
}
if (l1.val < l2.val) {
l1.next = mergeTwoLists(l1.next, l2);
return l1;
} else {
l2.next = mergeTwoLists(l1, l2.next);
return l2;
}
};
删除排序数组中的重复项
给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4], 函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。 你不需要考虑数组中超出新长度后面的元素。说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums); // 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }
/**
* @param {number[]} nums
* @return {number}
*/
var removeDuplicates = function (nums) {
for (let i = 0; i < nums.length; i++) {
if (nums[i] === nums[i + 1]) {
nums.splice(i, 1);
i--;
}
}
return nums.length;
};
删(xiu)除(gai)
var removeDuplicates = function (nums) {
var len = 1;
for (var i = 1; i < nums.length; i++) {
if (nums[i] !== nums[i - 1]) {
nums[len++] = nums[i];
}
console.log(nums)
}
return len;
};
移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。 注意这五个元素可为任意顺序。 你不需要考虑数组中超出新长度后面的元素。说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝 int len = removeElement(nums, val); // 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }
/**
* @param {number[]} nums
* @param {number} val
* @return {number}
*/
var removeElement = function(nums, val) {
let len = 0;
for (let i = 0; i < nums.length; i++) {
if (nums[i] !== val) {
nums[len++] = nums[i];
}
}
return len;
};
搜索插入位置(二分法)
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5 输出: 2示例 2:
输入: [1,3,5,6], 2 输出: 1示例 3:
输入: [1,3,5,6], 7 输出: 4示例 4:
输入: [1,3,5,6], 0 输出: 0
/**
* @param {number[]} nums
* @param {number} target
* @return {number}
*/
var searchInsert = function (nums, target) {
nums.push(target);
return nums.sort((a, b) => a - b).indexOf(target);
};
二分法
var searchInsert = function (nums, target) {
var left = 0;
var right = nums.length - 1;
if (target > nums[right]) {
return right + 1;
}
while (left < right) {
var index = parseInt((left + right) >>> 1); //取左中位数
if (nums[index] < target) {
left = index + 1;
//中位数小于目标值，削去区间左侧
} else {
right = index;
//中位数大于等于目标值，削去区间右侧
}
}
return left;
};
最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。进阶:
如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。
动态规划
/**
* @param {number[]} nums
* @return {number}
*/
var maxSubArray = function(nums) {
let ans = nums[0];
let sum = 0;
for (const num of nums) {
if (sum > 0) {
sum += num;
} else {
sum = num;
}
ans = Math.max(ans, sum);
}
return ans;
};
最后一个单词的长度
给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。
示例:
输入: "Hello World" 输出: 5
/**
* @param {string} s
* @return {number}
*/
var lengthOfLastWord = function(s) {
const arr = s.trim().split(' ');
return arr[arr.length - 1].length;
};
var lengthOfLastWord = function (s) {
let end = s.length - 1;
while (end >= 0 && s[end] == ' ') {
end--;
}
if (end < 0) {
return 0;
}
let start = end;
while (start >= 0 && s[start] != ' ') {
start--;
}
return end - start;
};
加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3] 输出: [1,2,4] 解释: 输入数组表示数字 123。示例 2:
输入: [4,3,2,1] 输出: [4,3,2,2] 解释: 输入数组表示数字 4321。
/**
* @param {number[]} digits
* @return {number[]}
*/
var plusOne = function(digits) {
for (let i = digits.length - 1; i >= 0; i--) {
digits[i]++;
if (digits[i] === 10) {
digits[i] = 0;
if (i === 0) {
return [1, ...digits];
}
} else {
break;
}
}
return digits;
};
大佬思路
var plusOne = function(digits) {
const len = digits.length;
for(let i = len - 1; i >= 0; i--) {
digits[i]++;
digits[i] %= 10;
if(digits[i]!=0)
return digits;
}
return [1, ...digits];
};
二进制求和
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
示例 1:
输入: a = "11", b = "1" 输出: "100"示例 2:
输入: a = "1010", b = "1011" 输出: "10101"提示：
- 每个字符串仅由字符 '0' 或 '1' 组成。
- 1 <= a.length, b.length <= 10^4
- 字符串如果不是 "0" ，就都不含前导零。
/**
* @param {string} a
* @param {string} b
* @return {string}
*/
var addBinary = function (a, b) {
const diff = a.length - b.length;
if (diff < 0) {
for (let i = 0; i < -diff; i++) {
a = '0' + a;
}
}
if (diff > 0) {
for (let i = 0; i < diff; i++) {
b = '0' + b;
}
}
let arrA = a.split('');
let arrB = b.split('');
const len = a.length;
let carry = 0;
for (let i = len - 1; i >= 0; i--) {
const num = parseInt(arrA[i]) + parseInt(arrB[i]) + carry;
carry = num === 1 || num === 0 ? 0 : 1;
if (num !== 0) {
arrA[i] = num % 2 === 0 ? '0' : '1';
}
}
if (carry === 1) {
return ['1', ...arrA].join('');
}
return arrA.join('');
};
大佬做法
var addBinary = function(a, b) {
let ans = "";
let ca = 0;
for(let i = a.length - 1, j = b.length - 1;i >= 0 || j >= 0; i--, j--) {
let sum = ca;
sum += i >= 0 ? parseInt(a[i]) : 0;
sum += j >= 0 ? parseInt(b[j]) : 0;
ans += sum % 2;
ca = Math.floor(sum / 2);
}
ans += ca == 1 ? ca : "";
return ans.split('').reverse().join('');
};
x 的平方根(二分法)
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4 输出: 2示例 2:
输入: 8 输出: 2说明: 8 的平方根是 2.82842...,
由于返回类型是整数，小数部分将被舍去。
/**
* @param {number} x
* @return {number}
*/
var mySqrt = function (x) {
if (x == 0 || x == 1) {
return x;
}
var left = 1;
var right = x;
while (left <= right) {
var middle = left + ((right - left) >>> 1);
if (middle * middle === x) {
return middle;
} else if (middle * middle > x) {
right = middle - 1;
} else {
left = middle + 1;
}
}
return right;
};