插入：20. 有效的括号
const L= {
"(": ")",
"[": "]",
"{":"}",
}
var isValid = function(s) {
let arr=[];
for(let i = 0; i< s.length; i++){
if(s[i]=='('|| s[i]=='{' || s[i] =='['){
arr.push(L[s[i]]);
} else {
if(!arr.length || arr.pop()!== s[i]){
return false;
}
}
}
if(arr.length != 0){
return false;
}
return true;
}
/**
* 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 maxDepth = function(root) {
if(root == null){
return 0
}
return Math.max(maxDepth(root.left), maxDepth(root.right)) +1
};121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
思路：遍历一遍，将最小值记录下来，然后对比当前值和最小值的差值
/**
* @param {number[]} prices
* @return {number}
*/
var maxProfit = function(prices) {
let min = prices[0] //min为最小值
let res = 0 //res为差值
for(let i =1; i<prices.length; i++){
min = Math.min(min, prices[i]) //比较最小值和当前值，选最小
res = Math.max(res, prices[i]- min) // 比较最小差值和当前差值
}
return res
};141. 环形链表
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。 否则，返回 false 。
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @return {boolean}
*/
var hasCycle = function(head) {
let p = q = head
if(p == null){ //判断头是否为空，不然后面q.next会执行出错
return false
}
while(q.next!=null && q.next.next !=null){
p = p.next;
q = q.next.next
if(q == p && q!=null && p !=null){
return true
}
}
return false
};101对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
分析：这道题难点在于递归，是我已知以来的难点，很多时候明明知道用递归，但还是会不知所措。
var isSymmetric = function(root) {
//判断根是否为空
if(root==null){
return true;
}
return isTrue(root.left, root.right);
};
//递归判断是否为对称，很容易想到，要判断左子树和右子树的值是否一致，
//若一致，再判断其左子树的左值和右子树的右值是否一致，以及左子树的右值和右子树的左值是否一致，
//其实这个过程是在判断相应的子树是否对称。终止条件就是若左右其中一个为空，则假，若左右均为空，则真。
function isTrue(leftTree, rightTree){
if(leftTree == null && rightTree ==null){
return true;
}
if((!leftTree && rightTree) || (leftTree && !rightTree)){
return false;
}
return (leftTree.val == rightTree.val&& isTrue(leftTree.right, rightTree.left) && isTrue(leftTree.left, rightTree.right))
}21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} l1
* @param {ListNode} l2
* @return {ListNode}
*/
//难点：总是碰到指针问题就不知所措
//两个不同长度的链表，判断到最后，如果一个为空 ，则将另外一个正便利的节点附给那个节点的next就行
var mergeTwoLists = function(l1, l2) {
let p = l1;
let q = l2;
let head = new ListNode(-1);
let prev = head;
if(l1 == null){
return l2;
}else if(l2 ==null){
return l1;
}
while(l1 && l2){ //判断是否一方已遍历完成
if(l1.val <= l2.val){
prev.next = l1; //用的原来的节点而不是新创节点
l1 = l1.next;
}else if(l1.val >= l2.val){
prev.next = l2;
l2 = l2.next;
}
prev = prev.next;
}
prev.next = l1 == null ? l2 : l1; //如何让处理剩下的节点，像链表是连着的就可以直接确定一个就行，数组不同的地方就是需要一个个加进去
return head.next;
};11. 盛最多水的容器
给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。说明：你不能倾斜容器。
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
/**
* @param {number[]} height
* @return {number}
*/
//双指针方法
var maxArea = function(height) {
//解构语法进行赋值,若做指针值小于右指针，则计算体积，并将左指针右移，否则计算体积，并将左指针移动。为什么每次都将短的一方移动呢，因为V = 短板长度*t, t为两个值的间距，但是无论右指针左移还是左指针右移，下一个t为t-1，肯定会减小，所以我们只需关注新短板长度即可。如果移动长板的话，短板肯定不变或者较少，肯定不会变大。但是移动短板的话，可能会变大或者不变或者减少。
let [maxV, i, j] =[0, 0, height.length -1];
while(i < j){
if (height[i] <= height[j]){
maxV = Math.max(maxV , (j-i) * height[i]);
i++;
} else if(height[i] > height[j]){
maxV = Math.max(maxV , (j-i) * height[j]);
j--;
}
}
return maxV;
};5. 最长回文子串（2021.7.25）
给你一个字符串 s，找到 s 中最长的回文子串。
// 方法一：暴力解决
// 遍历每个子串，看是否是回文串
/**
* @param {string} s
* @return {string}
*/
var longestPalindrome = function(s) {
let len = (s.length + 1) * s.length /2;
let max =0;
let map1 = new Map();
for(let i =0; i< s.length; i++){
for(let j =i; j<s.length;j++){
if(isTruth(s.slice(i,j+1))){
if(s.slice(i,j+1).length > max) {
map1.set(s.slice(i,j+1).length, s.slice(i,j+1));
max = s.slice(i,j+1).length;
}
}
}
}
return map1.get(max);
};
var isTruth = ( subStr) =>{
for(let i = 0; i< Math.ceil(subStr.length/2); i++){
if(subStr[i] != subStr[subStr.length - i -1]){
return 0;
}
}
return 1;
}
//中心扩展法
//思路：从左到右每次选一个数作为中心，向左右两边扩展，先找到相同的元素（先向右循环，直至不相等，再向左循环，直至不相等），然后再看左右两边的元素是否相等，如果相等，分别向左向右移动。不等则计算
var longestPalindrome = function(s){
let len;
let max = 0;
// 取最长长度时的maxStart，maxEnd，其实maxStart代表索引的前一位，maxEnd代表索引的后一位。
let maxStart = maxEnd = 0;
//遍历所有元素
for(let cur = 0; cur <s.length; cur++){
let right = left = cur;
//先向右循环，此时right指向不相等的那个元素，right最大值为s.length，即右索引的后一个
while(right <= s.length){
if(s[right] != s[cur] ){
break;
}
right ++;
}
//再向左循环，此时left指向不相等的那个元素，left最小为-1,即左索引的前一位
while(left>= 0){
if(s[left] != s[cur] ){
break;
}
left--;
}
//分别向左向右移动
while(left>= 0 && right <= s.length && s[right] == s[left]){
left--;
right++;
}
maxStart = len > max ? left : maxStart;
maxEnd = len > max ? right : maxEnd;
max = len > max ? len : max;
}
return s.slice(maxStart+1, maxEnd);
}插播1（2021字节前端提前批，惨痛的教训）
415.给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。（2021.7.24）
/**
* @param {string} num1
* @param {string} num2
* @return {string}
*/
// 方法一
var addStrings = function(num1, num2) {
let res = '';
let len1 = num1.length;
let len2 = num2.length;
let i = 0, j = 0, temp = 0;
// 填充0
len1 < len2 ? num1 = num1.padStart(len2, '0') : num2 = num2.padStart(len1, '0');
let newLen = len1 > len2 ? len1 :len2;
for(let i = newLen - 1; i >= 0; i--){
let sum = parseInt(num1[i]) + parseInt(num2[i]) + temp;
temp = sum > 9 ? 1 : 0; //可优化为temp = Math.floor(sum / 10)
res = (sum > 9 ? sum % 10 : sum) + res; // res = sum % 10
}
if(temp === 1){
res = '1' + res;
}
return res;
};
//方法二： 上面占据了很多空间，可以进行判断.但这种虽然时间快，但占内存
//执行用时：92 ms , 在所有 JavaScript 提交中击败了 68.05%的用户
//内存消耗： 39.9 MB , 在所有 JavaScript 提交中击败了 69.93%的用户
var addStrings = function(num1, num2) {
let i = num1.length - 1, j = num2.length - 1, add = 0;
const ans = [];
while (i >= 0 || j >= 0 || add != 0) {
const x = i >= 0 ? num1.charAt(i) - '0' : 0;
const y = j >= 0 ? num2.charAt(j) - '0' : 0;
const result = x + y + add;
ans.push(result % 10);
add = Math.floor(result / 10);
i -= 1;
j -= 1;
}
return ans.reverse().join('');
};
4. 寻找两个正序数组的中位数（2021.7.22）
/**
* @param {number[]} nums1
* @param {number[]} nums2
* @return {number}
*/
var findMedianSortedArrays = function(nums1, nums2) {
//整体思路：把这两个数组遍历按照大小顺序保存在一个新数组中，然后再更具两者长度是奇数还是偶数来输出结果
let len1 = nums1.length;
let len2 = nums2.length;
let mid = (len1+len2) /2;
let temp = 0;
let i= 0,j=0;
let arr =[];
while(i<len1 || j<len2){
if(nums1[i]<=nums2[j] || j>= len2 && i< len1){
arr[temp] = nums1[i]
i++;
}else{
arr[temp] = nums2[j]
j++;
}
temp++;
// if(temp>mid){
// break;
// }
}
let res = ((len1+len2)%2 === 1) ? arr[Math.floor(arr.length / 2)] : (arr[arr.length / 2 - 1] + arr[arr.length / 2]) / 2
return res;
};试图优化，但失败，目前的复杂度为O（m+n），本来想判断一下temp如果大于一半的话，就提前break，但是不知道是不是js不允许arr[temp]，所以解决不出来，虽然这个判断并不影响复杂度，因为官方可以给出O(log（m+n))的复杂度：可以用二分查找方法。
- 无重复字符的最长子串（2021.7.21）
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
/**
* @param {string} s
* @return {number}
*/
var lengthOfLongestSubstring = function(s) {
let map = new Map();
let max = 0;
let start = 0;
let end = 0;
while(end != s.length){
if(!map.has(s[end])){
} else {
start = map.get(s[end]) > start ? map.get(s[end]) : start;
}
map.set(s[end], end+1);
ans = end - start +1;
end++;
max = ans > max ? ans : max;
}
return max;
}2.两数相加（2021.7.20）
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} l1
* @param {ListNode} l2
* @return {ListNode}
*/
var addTwoNumbers = function(l1, l2) {
let temp = 0;
let head = null;
let tail = null;
while(l1 || l2){
let a = l1 ? l1.val : 0;
let b = l2 ? l2.val : 0;
let sum = a + b + temp;
if(!head){
head = tail = new ListNode(sum%10, null);
} else{
tail.next = new ListNode(sum%10);
tail = tail.next;
}
temp = sum > 9 ? 1 : 0;
if(l1){
l1 = l1.next;
}
if(l2){
l2 = l2.next;
}
}
if(temp>0){
tail.next = new ListNode(temp);
}
return head;
};
1.两数之和（2021.7.20）
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
var twoSum = function(nums, target) {
let numsSet = new Set();
for(let i=0;i<nums.length;i++){
let temp = target-nums[i]
if(numsSet.has(temp)){
return [i,nums.indexOf(temp)]
}
numsSet.add(nums[i])
}
};
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。