53. 最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
var maxSubArray = function(nums) {
let sum = 0;
let maxRes=nums[0];
for(let i=0;i<nums.length;i++){
if(sum>0){
sum+=nums[i]
}else{
sum=nums[i]
}
maxRes = Math.max(maxRes,sum)
}
return maxRes
};
58. 最后一个单词的长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
var lengthOfLastWord = function(s) {
const arr = s.trim().split(' ');
console.log(arr)
return arr.pop().length
};
66. 加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头
var plusOne = function (digits) {
if (digits.findIndex(e => e !== 9) > -1) {
// 不全是9
let i = digits.length - 1
while (digits[i] === 9) {
digits[i] = 0;
i--
}
digits[i] = digits[i] + 1
return digits
} else {
for (let i = digits.length; i > 0; i--) {
digits[i] = 0
}
digits[0] = 1
return digits
}
};
67. 二进制求和
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
var addBinary = function (a, b) {
let res = [], tag = 0
for (let i = a.length - 1, j = b.length - 1; i >= 0 || j >= 0; i--, j--) {
let itemA = i >= 0 ? Number(a[i]) : 0, itemB = j >= 0 ? Number(b[j]) : 0;
res.unshift((itemA + itemB + tag) % 2)
tag = Math.floor((tag + itemA + itemB) / 2)
}
if (tag) {
res.unshift(tag)
}
return res.join('')
};
69. x 的平方根
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
注意： 不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
var mySqrt = function (x) {
if (x === 0 || x === 1) {
return x
}
let left = 0, right = x, mid = Math.floor(x / 2)
while (left <= right) {
mid = Math.floor((left + right) / 2)
if (mid * mid <= x && (mid + 1) * (mid + 1) > x) {
return mid
}
if (mid * mid < x) {
left = mid + 1
} else {
right = mid - 1
}
}
};
70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
var climbStairs = function (n) {
const res = new Array(n + 1).fill(0);
res[0] = 1;
res[1] = 1;
for (let i = 2; i <= n; i++) {
res[i] = res[i - 2] + res[i - 1];
}
console.log(res)
return res[n];
};
83. 删除排序链表中的重复元素
给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
var deleteDuplicates = function (head) {
let tag = head;
while (tag && tag.next) {
if (tag.val == tag.next.val) {
tag.next = tag.next.next
} else {
tag = tag.next
}
}
return head
};
88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 **和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 **到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意： 最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
var merge = function (nums1, m, nums2, n) {
for (let i = 0; i < n; i++) {
nums1[m + i] = nums2[i]
}
for (let j = nums1.length; j > 0; j--) {
for (let k = 0; k < j; k++) {
if (nums1[k] > nums1[k + 1]) {
[nums1[k], nums1[k + 1]] = [nums1[k + 1], nums1[k]]
}
}
}
};
94. 二叉树的中序遍历
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
var inorderTraversal = function (root) {
if (root === null) return [];
const left = inorderTraversal(root.left);
const right = inorderTraversal(root.right);
// 中序
return [...left, root.val, ...right];
// 前序
// return [root.val, ...left, ...right];
// 后序
// return [...left, ...right, root.val];
};
100. 相同的树
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
var isSameTree = function (p, q) {
if (p == null && q == null) {
return true;
}
if (p == null || q == null) {
return false;
}
if (p.val != q.val) {
return false;
}
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
};
