1.两数之和

题目：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

初版思路：

记录每一个数的值和下标，然后找到对应的差的下标，如果存在且两个下标不同则返回

    for(let i=nums.length-1;i;i--){const val1=nums[i]const indexList=nums.map((item,index)=>{return {value:item,index:index}}).filter(item=>item.value===target-val1).map(item=>item.index)const index=indexList.find((item)=>{return item!==i})if(index!==undefined){return [index,i]}}

问题：循环用的太多，数据转换也太多，导致性能不够好。

优化方向：

先判断差在原数组是否存在，如果不存在则直接跳到下一个循环

var twoSum = function(nums, target) {for(let i=nums.length-1;i;i--){const v=nums[i]const a=target-v;if(nums.includes(a)){for(let s=0;s<i;s++){if(nums[s]===a){return [s,i]}}}}
};

问题：

循环嵌套，性能可以进一步优化，比较次数可以少一点

优化方向：

采用值-下标的方式，在单次循环中记录值和下标的关系，然后判断差对应的key在对象中是否存在即可。

var twoSum = function(nums, target) {const m={};for(let i=nums.length-1;i>=0;i--){const v=nums[i];if(m[target-v]!==void 0){return [i,m[target-v]]}m[v]=i}
};

2.整数反转

题目:

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

思路：先转换成字符串，切割成数组，然后用数组的reverce方法反转

var reverse = function(x) {
const i=(value)=>{return value>=(-1*Math.pow(2,31))&&value<=(Math.pow(2,31)-1)
}
let v;
if(x>=0){v=Number(`${x}`.split('').reverse().join(''))}else{
v=-1* Number(`${-1*x}`.split('').reverse().join(''))
}
return i(v)?v:0
};

问题：内存消耗较大，因为有多次的切割及合并操作

优化方向：

对字符串采用单次循环的方式，在循环中拼接

var reverse = function(x) {
const i=(value)=>{return value>=-2147483648&value<=2147483647
}
let vlet a=''let s
if(x>=0){s=x.toString();}else{s=(-1*x).toString();
}for(j=s.length-1;j>=0;j--){a+=s[j]}
v=x>=0?Number(a):-1*Number(a)
return i(v)?v:0
};

3.回文数

题目：判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

思路：先区分简单情况，负数肯定不是，小于10的数肯定是。

然后将数字转换成字符串，在单次循环中，判断某个下标及镜像下标上的数是否相等

var isPalindrome = function(x) {
if(x<0){return false
}else if(x<=9){return true
}
const a=x+''
const l=a.length
const i=Math.floor(l/2)
for(let j=i;j;j--){if(a[j-1]!==a[l-j]){return false}
}
return true
};