挑战LeetCode热题100（TS版本）

打卡第二天

1、移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。 示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

思路： 思路一：splice + push + 判断首位是否为0

    function moveZeroes(nums: number[]): void {
    let left = 0;
    let right = nums.length - 1
    while(left <= right) {
        if(nums[left] === 0) {
            nums.splice(left, 1)
            nums.push(0)
            right--
            if(nums[left] !== 0) {
                left++
            } 
        } else {
            left++
        }
    }
};

• 时间复杂度：O$(n)$
• 空间复杂度：O$(1)$

思路二：收集不为0的元素然后补0

function moveZeroes(nums: number[]): void {
    let s = 0
    for(let i=0;i<nums.length;i++) {
        if(nums[i] !== 0) {
            nums[s++] = nums[i]
        }
    }

    for(let i=s;i<nums.length;i++) {
        nums[i] = 0
    }
}

• 时间复杂度：O$(n)$
• 空间复杂度：O$(1)$

2、三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例 1：

输入： nums = [-1,0,1,2,-1,-4]
输出： [[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入： nums = [0,1,1]
输出： []
解释： 唯一可能的三元组和不为 0 。

示例 3：

输入： nums = [0,0,0]
输出： [[0,0,0]]
解释： 唯一可能的三元组和为 0 。

思路：暴力破解（超时）、双指针

暴力破解：

    function threeSum(nums: number[]): number[][] {
    const target = 0
    const result = []
    for(let i=0;i<nums.length;i++) {
        for(let j=i+1;j<nums.length;j++) {
            for(let s=j+1;s<nums.length;s++) {
                if(nums[i] + nums[j] + nums[s] === target) {
                    const cur = [nums[i],nums[j],nums[s]].sort((a,b) => a-b)
                    const isAllZero = cur.every(item => item === 0)
                    const isResultZero = result.filter(item => item.every((e: number) => e === 0))
                    if(isAllZero && !isResultZero.length) {
                        result.push(cur)
                    } else {
                         const res = result.filter(item => item.includes(nums[i]) && item.includes(nums[j]) && item.includes(nums[s]))
                        if(!res.length) {
                            result.push(cur)
                        }
                    }
                }
            }
        }
    }
    return result
};

• 时间复杂度：O$(n*n*n)$
• 空间复杂度：O$(1)$

双指针-二分

function threeSum(nums: number[]): number[][] {
    const target = 0
    const result = []
    const arr = nums.sort((a,b) => a - b)
    for(let i=0; i < arr.length - 2; i++) {
        if(i > 0 && arr[i] === arr[i-1]) {
            continue;
        }
        let left = i + 1
        let right = arr.length - 1
        while(left < right) {
            const sum = arr[i] + arr[left] + arr[right]
            if(sum === target) {
                result.push([arr[i], arr[left], arr[right]])
                while(left < right && arr[left] === arr[left+1]) {
                    left++
                }
                while(left < right && arr[right] === arr[right - 1]) {
                    right--
                }
                left++
                right--
            } else if (sum > target) {
                right--
            } else {
                left++
            }
        }
    }
    return result
};

• 时间复杂度：O$(n*n)$
• 空间复杂度：O$(1)$

**总结：**前面两道题的推荐解法是双指针，当然还有更优的解法，欢迎评论和指正！