var moveZeroes = function(nums) {let left = 0,right = 0while(right < nums.length){if(nums[right]){[nums[right],nums[left]] = [nums[left],nums[right]]left ++}right++}
};

实现的思路在于定义两个指针，遍历数组，每一次遍历都会 向右移动right指针 的位置，但是只有 当前遍历值值不为零 才移动left的位置，这样就实现了 将left一直保留在0 的位置，如果值不为零就将它与left调换位置，把不为零的值调到前面去。循环结束后不为零的值就都移动到左侧去了。

这里换一种写法更加直观，是不是顿时清晰了：

/*** @param {number[]} nums* @return {void} Do not return anything, modify nums in-place instead.*/
var moveZeroes = function(nums) {let zeroPosition = 0nums.forEach((item,index)=>{if(item){[nums[zeroPosition],nums[index]] = [nums[index],nums[zeroPosition]]zeroPosition++}})
};

数字溢出的阈值通过 Math.pow 来计算，正负的记录则使用 Math.sign

• Math.pow(2,31)获取最大数字
• Math.sign()获取数字的正负

var reverse = function(x) {const sign = Math.sign(x)x = Math.abs(x)const num =  sign * parseInt(('' + x).split('').reverse().join('')) if(num > Math.pow(2,31)||num < Math.pow(-2,31)){return 0}return num
};

这题比较简单，转换为字符串再转换为数组后翻转， 翻转后再转为数字，进行一个判断即可~

这一题的要求是不能转换为字符串去判断是否为回文数。

实现的核心在于创建一个新变量，将数字给翻转过来之后赋值给新变量，并判断新变量是否与传入的数字相同。

/*** @param {number} x* @return {boolean}*/
var isPalindrome = function(x) {if(x < 0|| (x!==0&&x%10 ===0)){return false}let resverNum = 0let num = xwhile(num){resverNum = resverNum * 10 + num % 10num = Math.floor(num/10)}return x === resverNum
};

首先排除一部分的数值，负数 以及 非零可以被10整除的数字 ，因为如果最后一位为0的话第一位必须是0，但是整数的第一位不可能是零所以要排除这种情况。

接下来就是翻转数字，实现的方式是先创建一个新的数值，初始值为0。将原数字除十取余数，并将余数加到新变量上，原数字不断除十直到取整后为0，而新变量每次循环都乘十再加余数，这样循环完成后数字就翻转过来了。

/*** @param {string} s* @return {boolean}*/
var isValid = function(s) {const arr = s.split('')if(arr.length % 2 !== 0){return false}const map = {'(':')','{':'}','[':']'}const stack = []for(let item of s){if(map[item]){stack.unshift(map[item])}else{const match = stack.shift()if(match !== item){return false}}}if(stack.length){return false}return true
};

这题是面试老客户了，虽然我没刷过 leetcode，但是对于这一题还是很亲切的哈哈哈。

实现的思路在于两点，一个是创建一个对象用于 存储括号的对应关系，再创建一个栈，利用栈 后进先出 的特点来匹配括号

在js中实现栈的话就是通过数组模拟，使用 unshift 和 shift 两个api模拟入栈出栈操作。

var maxArea = function(height) {let maxV = 0let left = 0let right = height.length - 1while(left<right){const V = (right - left) * Math.min(height[left],height[right])height[left]>height[right]?right--:left++if(V>maxV){maxV = V}}return maxV
};

这一题的思路是使用双指针，容器的体积通过 指针的距离 * 两个指针中小的那个值 计算，然后判断哪一边的指针指向的值小，将那一边指针向中间偏移，直到两个指针相遇。

/*** @param {string[]} strs* @return {string}*/
var longestCommonPrefix = function(strs) {if(!strs.length){return ""}const minLength = Math.min(...strs.map(item=>item.length)) const publicStrArr = []for(let i = 0;i<minLength;i++){let isPublic = truefor(let strIndex in strs){if(!strs[strIndex][i]||strs[strIndex][i]!==strs[0][i]){isPublic = falsebreak}}if(!isPublic){break}publicStrArr.push(strs[0][i])}return publicStrArr.join('')
};

这一题总感觉我的解决方式不是很优雅😅，首先我获取数组中长度最小的值的长度，然后执行两层遍历，外层是用于遍历数组内的每一个字符串，内层是遍历字符串数组。通过 isPublic 变量来判断数组中所有字符串的strIndex 位置的值是否相同，如果不同就跳出循环，如果相同就push进数组中。最后将数组拼接为字符串返回。

这种两数之和我最习惯的就是使用map的解法，利用对象可以通过 键的唯一性和映射关系 实现很多方便的功能。

/*** @param {number[]} numbers* @param {number} target* @return {number[]}*/
var twoSum = function(numbers, target) {const map = {}for(let i in numbers){if(!map[target - numbers[i]] ){map[numbers[i]] = i}else{return [parseInt(map[target - numbers[i]])+1,parseInt(i)+1 ]}}
};

首先创建一个对象map，然后遍历数字数组，两数之和其实就是不断的去将 target 值与遍历的到的数字取差，如果这个差值是map中已经有的值说明他们俩相加等于target 就可以返回啦。如果是map中没有的就 把这个值当做一个键添加在map中

由于数组时有序的，因此也满足二分查找的条件，使用二分查找的解法

var twoSum = function(numbers, target) {for(let i in numbers){i= parseInt(i)let left = i+ 1 let right = numbers.length - 1while(left <= right){const mid = Math.floor((right - left)/2 + left)if( numbers[i] + numbers[mid] === target){return [i+1,mid+1]}else if(numbers[i] + numbers[mid] < target){left = mid + 1}else{right = mid - 1}}}};

首先遍历数字数组，然后在当前遍历到的数字 右侧范围 进行一个二分查找，每一次 判断遍历到的数字 +
二分查找的中间值之和 与 target 的大小关系，然后不断缩小范围

var reverseWords = function(s) {s = s.split(' ').map(item=>item.split('').reverse().join('')).join(' ')return s
};

这题简单，一行就能搞定，先将数组以空格分割开，map遍历数组将数组中 每一个字符串给翻转后再将数组以空格拼接 起来，这样就可以保持字符串空格的位置保持不变。

这一题我认为对我帮助很大，让我学习到了一个快慢双指针实现指向链表中间位置的方法。

由于链表不能直接获取中间位置的指针，因此我们定义一快一慢两个指针，每次遍历时快的指针走两步，慢的指针走一步，快的走两步。当快的指针走到链表末尾时，慢的指针刚好走到链表中间。这个思路对于以前没刷题的我来说是很大启发哈哈~

var middleNode = function(head) {let slow,fastslow = fast = head;while (fast && fast.next) {//快慢指针遍历，直到快指针到达最后slow = slow.next;fast = fast.next.next;}return slow;
};