leetcode，牛客网 javascript版本（更新中）
- 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。（假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。）
var reverse = function(x) {
const res=(Math.abs(x)+'').split('').reverse().join('')*(x>0?1:-1);
return res<-Math.pow(2,31)||res>Math.pow(2,31)?0:res;
};
- 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
var lengthOfLongestSubstring = function(s) {
let result=[];
let now=0;
let arr=s.split('');
arr.forEach((value,index)=>{
let currentIndex=result.indexOf(value);
result.push(value)
result=result.slice(currentIndex+1);
if(now<result.length){
now=result.length;
}
})
return now;
};
-
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
var lengthOfLongestSubstring = function(s) {
let result=[];
let now=0;
let arr=s.split('');
arr.forEach((value,index)=>{
let currentIndex=result.indexOf(value);
result.push(value)
result=result.slice(currentIndex+1);
if(now<result.length){
now=result.length;
}
})
return now;
};
-
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
var plusOne = function (digits) {
digits[digits.length-1] += 1;
console.log(digits)
var i = digits.length-1;
while (true) {
if (digits[i] >= 10) {
digits[i] = 0;
if (digits[i-1] === undefined) {
//倒数第二位没有
digits.unshift(1);
break;
} else {
digits[i-1] += 1
}
i--
}
else {
break;
}
}
return digits
}
-
8 字符串转换整数 (atoi)
请你来实现一个 atoi 函数，使其能将字符串转换成整数。首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。
在任何情况下，若函数不能进行有效的转换时，请返回 0。
var myAtoi = function(str) {
return Math.max(Math.min(parseInt(str) || 0, 2147483647), -2147483648)
};
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
/*
* 1、直接用三个 for 循环遍历所有数据，找出符合条件的数据，时间复杂度为 O(n^3)。能不能更快效率？
2、先对数组内数据进行一次排序。O(nlogn)
3、最外层一个 for 循环,先把其中一个值固定住(存放到变量)，然后分别用两个指针指向数据的非固定值的头部和尾部，通过 while 循环来遍历。
4、如果三个数据相加等于 0 了，就存储该三个值且更新 head 和 end 指针。
5、如果不等于小于或大于 0 ,就更新 head 和 end 指针移动重新查找符合条件的值。
6、返回结果集 result。
* */
var threeSum = function(nums) {
let result=[];
let head;
let end;
let fixedVal;
nums.sort(function (a,b) {
return a-b;
})
//判断数组内元素是否都为整数或负数，直接返回
if(nums[0]>0||nums[nums.length-1]<0||nums.length<3){
return result;
}
//遍历
for(let i=0;i<nums.length;i++){
fixedVal=nums[i];
if(fixedVal === nums[i-1]) continue;
//一开始的固定值为nums[0],所以头指针为 i+1 下一个元素
head=i+1;
//尾指针
end=nums.length-1;
//如果头指针小于尾指针
while(head<end){
if(nums[head]+nums[end]+fixedVal==0){
let group=[];
group.push(nums[head],nums[end],fixedVal);
result.push(group);
//存放完毕之后，不要忘记头指针和尾指针的移动(否则会产生死循环)
head+=1;
end-=1;
//如果头指针满足小于尾指针且移动后的指针和移动前的指针元素相等，再往前移动
while(head<end&&nums[head]==nums[head-1]){
head+=1;
}
//如果头指针满足小于尾指针且移动后的指针和移动前的指针元素相等，再往后移动
while(head<end&&nums[end]==nums[end+1]){
end-=1;
}
}
else if(nums[head]+nums[end]+fixedVal<0){
head++;
}
else{
end--
}
}
}
return result;
}
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
var searchInsert = function(nums, target) {
var index=nums.indexOf(target);
var currentIndex;
if(index!=-1){
return index;
}
else{
for(var i=0;i<nums.length;i++){
if(target<=nums[i]){
nums.splice(i,0,target);
currentIndex=i;
break;
}
else if(target>=nums[i]&&nums[i+1]>=target){
console.log(nums[i],nums[i+1])
nums.splice(i+1,0,target);
currentIndex=i+1;
break;
}
else if(target>=nums[nums.length-1]){
nums.push(target);
currentIndex=nums.length-1;
break;
}
}
}
return currentIndex;
};
给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。
示例 1:
输入: [10,2]
输出: 210
示例 2:
输入: [3,30,34,5,9]
输出: 9534330
说明: 输出结果可能非常大，所以你需要返回一个字符串而不是整数。
var largestNumber = function(nums) {
nums.sort((a,b)=>{
return parseInt(`${b}${a}`)-parseInt(`${a}${b}`)
})
return nums.join('').replace(/^[0]+/,'0')
};
存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
var containsDuplicate = function(nums) {
let arr=[...new Set(nums)];
return arr.length!=nums.length
};
为 Array 对象添加一个去除重复项的方法
示例1
输入
[false, true, undefined, null, NaN, 0, 1, {}, {}, ‘a’, ‘a’, NaN]
输出
[false, true, undefined, null, NaN, 0, 1, {}, {}, ‘a’]
//方法1
Array.prototype.uniq = function () {
var arr=[];
var flag=true;
for(var i=0;i<this.length;i++){
if(arr.indexOf(this[i])==-1){
if(this[i]!=this[i]){
if(flag){
arr.push(this[i])
flag=false;
}
}
else{
arr.push(this[i])
}
}
}
return arr;
}
//方法2
Array.prototype.uniq = function () {
return [...new Set(this)];
}
查找两个节点的最近的一个共同父节点，可以包括节点自身
function commonParentNode(oNode1, oNode2) {
if(oNode1.contains(oNode2)){
return oNode1;
}
else{
return commonParentNode(oNode1.parentNode,oNode2)
}
}
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
function GetLeastNumbers_Solution(input, k)
{
// write code here
var result=input.sort(function(a,b){
return a-b;
})
return result.length>=k?result.slice(0,k):[]
}
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
function FindGreatestSumOfSubArray(array){
var max=array[0];
var thum=array[0];
for(var i=1;i<array.length;i++){
if(thum>0){
thum+=array[i]
}
else{
thum=array[i]
}
max=Math.max(thum,max)
}
return max
}