【前端】记录自己在leetcode上的刷题之路

每日一题，加油冲！

1.只出现一次数字

• 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素

解题思路1：利用Set对象的特性，只能存储任意类型的唯一值，来筛选出重复的数据，再与保存的set对象里面的值进行比较

var singleNumber = function(nums) {
    let mySet = new Set();
    let repeatList = [];
    for(let i = 0; i < nums.length; i++) {
        if (mySet.has(nums[i])) {
            repeatList.push(nums[i]);
        } else {
            mySet.add(nums[i])
        }
        
    }
    //console.log("mySet",mySet);
    //console.log("repeatList",repeatList);
    const singleNum = Array.from(mySet).filter(item=>!repeatList.includes(item));
    console.log("singleNum",singleNum);
    return singleNum;
};
singleNumber([1,2,1,2,4,6,7,7,6])；

解题思路2：利用两层循环，找到重复的数据，再和原数组比较

/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function(nums) {
    let repeatList = [];
    for (let i = 0; i < nums.length; i++) {
        const outItem = nums[i];
        for(let j = i + 1; j < nums.length; j++){
            const innerItem = nums[j];
            if (outItem === innerItem) {
                repeatList.push(innerItem);            
　　　　　　　　　}
        }
    }
    console.log("repeatList", repeatList);
    const singleNum = nums.filter(item=>!repeatList.includes(item))
    console.log("singleNum", singleNum);
    return singleNum[0];
};
singleNumber([1,2,2,1,3])

2.给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

解题思路1：根据位置k，截取数组，再重新组合

　/** 
　　* @param {number[]} nums 
   * @param {number} k 
　　* @return {void} Do not return anything, modify nums in-place instead. 
 */
  var rotate = function(nums, k) {
    const len = nums.length
    const index = len? len - k : len 
    const arr = nums.splice(index)
    const dataset = arr.concat(nums)
    dataset.forEach((item,index)=>{
        nums[index] = item
    })
};

解题思路2：无限轮播思想，复制一份原数组，再与原数组组合形成新数组

　/** 
　　* @param {number[]} nums 
   * @param {number} k 
　　* @return {void} Do not return anything, modify nums in-place instead. 
 */

  var rotate = function(nums, k) {
    const len = nums.length
    const copyNums = [...nums,...nums]
    const index = len ? len - k%len : len
    const _nums = copyNums.splice(index, len)
    for(let i = 0; i < _nums.length; i++){
        nums[i] = _nums[i]
    }
};

 3.两个数组的交集

• 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
• 我们可以不考虑输出结果的顺序

• 例：输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
     输出：[4,9]

解题思路：先找出交集元素，然后统计交集元素在每个数组的出现次数，最后输出结果

// 如果有交集，获取交集元素在当前数组的出现次数
function getTimes(data=[], num){
    let times = 0
    data.forEach(item=>{
        if (item === num) {
            times+=1
        }
    })
    return times
}

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    let dataMap= {}; // 储存数组交集
    let data = []; // 返回交集
    for(let i = 0; i < nums1.length; i++) {
        const outItem = nums1[i];
        let crossObj = {}
        for(let j = 0; j < nums2.length; j++) {
            const innerItem = nums2[j]
            if (outItem === innerItem) {
                crossObj = {
                    num: outItem,
                    num1Times: getTimes(nums1, outItem), 
                    num2Times: getTimes(nums2, innerItem)
                }
            }
        }
        if (Object.keys(crossObj).length) {
            dataMap[crossObj.num] = crossObj
        }
    }
    for (let key in dataMap) {
        const val = dataMap[key]
        const len = Math.min(val.num1Times, val.num2Times)
        for (let m = 0; m < len; m++) {
            data.push(val.num)
        }
    }
    return data
};
intersect([1,2,2,1], [2,2]) // 返回结果[2,2]

  4.K连续位的翻转次数

•  在仅包含 0 和 1 的数组 A 中，一次 K 位翻转包括选择一个长度为 K 的（连续）子数组，同时将子数组中的每个 0 更改为 1，而每个 1 更改为 0。

返回所需的 K 位翻转的最小次数，以便数组没有值为 0 的元素。如果不可能，返回 -1。

解题思路：遍历数组A，遇到为0的开始翻转K个长度

/**
 * @param {number[]} A
 * @param {number} K
 * @return {number}
 */
var minKBitFlips = function(A, K) {
    const len = A.length
    let count = 0;
    for(let i = 0; i <len; i++) {
        // 开始翻转K个长度
        if (A[i] === 0 && len - i >= K) {
            count++
            for(let j = i; j < i + K; j++){
                A[j] = A[j]^1 // 异或运算符 reverseNum(A[j])
            }

        }
    }
    console.log(A)
    if (A.includes(0)) {
        count = -1
    }
    return count
};

function reverseNum(num){
    return typeof num === 'number'  
        ? num === 1 ? 0 : 1 
        : num
}

 5.托普利茨矩阵(20210222)

• 给你一个 m x n 的矩阵 matrix 。如果这个矩阵是托普利茨矩阵，返回 true ；否则，返回 false 。
• 如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是 托普利茨矩阵 。

解题思路：各自与比较左上方数值比较，如果不相等则不是托普利茨矩阵

/**
 * @param {number[][]} matrix
 * @return {boolean}
 */
var isToeplitzMatrix = function(matrix) {
    const len = matrix.length
    const nLen = matrix[0].length
    // 各自跟左上角的数值比较
    for(let i = 1; i<len; i++) {
        for(j = 1; j<nLen; j++) {
            if(matrix[i][j]!== matrix[i-1][j-1]){
                return false
            }
        }
    }
    return true
};

isToeplitzMatrix([[1,2,3,4],[5,1,2,3],[9,5,1,2]]) // true

 6.爱生气的书店老板

• 今天，书店老板有一家店打算试营业 customers.length 分钟。每分钟都有一些顾客（customers[i]）会进入书店，所有这些顾客都会在那一分钟结束后离开。在某些时候，书店老板会生气。 如果书店老板在第 i 分钟生气，那么 grumpy[i] = 1，否则 grumpy[i] = 0。 当书店老板生气时，那一分钟的顾客就会不满意，不生气则他们是满意的。书店老板知道一个秘密技巧，能抑制自己的情绪，可以让自己连续 X 分钟不生气，但却只能使用一次。请你返回这一天营业下来，最多有多少客户能够感到满意的数量。

• 示例：

输入：customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3
输出：16
解释：
书店老板在最后 3 分钟保持冷静。
感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.

解题思路：滑动窗口解法。先求不生气时间内的顾客数，然后滑动X个，找出各挽留了多少顾客数，找出挽留顾客数的最大值，再相加即可得最大满意顾客数

/**
 * @param {number[]} customers
 * @param {number[]} grumpy
 * @param {number} X
 * @return {number}
 */
var maxSatisfied = function(customers, grumpy, X) {
    // 思路：先求不生气时间内的顾客数，然后滑动X个，找出各挽留了多少顾客数，找出挽留顾客数的最大值，再相加即可得最大满意顾客数
    // 1.不生气时顾客数
    let cusNum = 0
    for(let i = 0; i < grumpy.length; i++){
        if (grumpy[i] === 0) {
            cusNum+= customers[i]
        }
    }
    // console.log("cusNum", cusNum)

    // 2.挽留的顾客数集合
    const reserveList = []
    for(let j = 0; j < grumpy.length; j++){
        if (j + X <= grumpy.length) {
            let num = 0
            for(let k = 0; k < X; k++) {
                if (grumpy[j+k] === 1) {
                    num += customers[j+k]
                }
            }
            reserveList.push(num)
        }
        
    }
    // console.log("reserveList", reserveList)
    // 找出挽留顾客数的最大值
    const reserve = Math.max(...reserveList)

    return cusNum + reserve
};

7.区域和检索 - 数组不可变（难度指数：简单）

• 给定一个整数数组  nums，求出数组从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点。

解题思路：先找出前缀和preSum，对于数组任意索引之间的总和sumRange，有sumRange = sums[j+1] - sums[i]

/**
 * @param {number[]} nums
 */
var NumArray = function(nums) {
    // 前缀和
    const len = nums.length
    this.preSum = new Array(len + 1).fill(0)
    for (let i = 0; i < len; i++) {
        this.preSum[i+1] = this.preSum[i] + nums[i]
    }
    console.log("preSum", this.preSum)
};

/** 
 * @param {number} i 
 * @param {number} j
 * @return {number}
 */
NumArray.prototype.sumRange = function(i, j) {
    return this.preSum[j+1] - this.preSum[i]
};

// 输入：["NumArray","sumRange","sumRange","sumRange"]  [[[-2,0,3,-5,2,-1]],[0,2],[2,5],[0,5]]
// 输出：[null,1,-1,-3]
/**
 * Your NumArray object will be instantiated and called as such:
 * var obj = new NumArray(nums)
 * var param_1 = obj.sumRange(i,j)
 */

 8.接雨水（难度指数：困难）

• 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
• 

 

 解题思路1：先找出每个位置i能接多少水，每个位置能接多少水取决于左右两侧最大值中的小的一个。 时间复杂度 O(n^2)  空间复杂度(1)

/**
 * @param {number[]} height
 * @return {number}
 */
var trap = function(height) {
    if (height.length === 0) {
        return 0
    }
    // 思路：先找出每个位置i能接多少水，每个位置能接多少水取决于左右两侧最大值中的小的一个。
    const len = height.length
    let res = 0
    for (let i = 1; i < len - 1; i++) {
        let leftMax = 0;
        let rightMax = 0;
        // 找出左边最高的柱子
        for (let j = i; j >=0; j--) {
            leftMax = Math.max(leftMax, height[j])
        }
        // 找出右边最高的柱子
        for(let j = i; j < len; j++){
            rightMax = Math.max(rightMax, height[j])
        }

        res += Math.min(leftMax, rightMax) - height[i]
    }
    return res
};

解题思路2：先找出左右最高柱子，再算能接多少水，降低复杂度，时间复杂度O(n)，空间复杂度O(n)

/**
 * @param {number[]} height
 * @return {number}
 */
var trap = function(height) {
    if (height.length === 0) {
        return 0
    }
    // 思路2：先找出左右最高柱子，再算能接多少水。
    // 优化性能
    const len = height.length
    let res = 0

    const leftMax = new Array(len)
    const rightMax = new Array(len)

    leftMax[0] = height[0]
    rightMax[len-1] = height[len-1]

    //计算leftMax从左到右
    for (let i = 1; i < len; i++) {
        leftMax[i] = Math.max(height[i], leftMax[i-1])
    }

    // 计算rightMax从右到左
    for(let j = len - 2; j >= 0; j--) {
        rightMax[j] = Math.max(height[j], rightMax[j + 1])
    }

    for (let i = 1; i < len - 1; i++) {
        res += Math.min(leftMax[i], rightMax[i]) - height[i]
    }
    return res
};

解题思路3：双指针法

/**
 * @param {number[]} height
 * @return {number}
 */
var trap = function(height) {
    if (height.length === 0) {
        return 0;
    }
    // 双指针法
    const len = height.length;
    let res = 0;

    let left = 0;
    let right = len - 1;

    let leftMax = height[0];
    let rightMax = height[len - 1];

    while(left <= right){
        leftMax = Math.max(leftMax, height[left]);
        rightMax = Math.max(rightMax, height[right]);

        // 木桶原理，能装多少水取决于矮的一边
        if (leftMax < rightMax) {
            // 只看左边的
            res += leftMax - height[left];
            left++;
        } else {
            // 只看右边
            res += rightMax - height[right];
            right--;
        }
    }
    return res;
};

 9.下一个排列（难度指数：中等）

• 实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
• 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
• 必须 原地 修改，只允许使用额外常数空间。

（ps:刚拿到这个题，题目也看不懂，没有思路，看了一个大佬解释，总算弄明白了）

解题思路：从后往前，找出开始升序的相邻两个数的位置i和j，然后找出位置j后面，最小的大数（不仅仅是大于i位置的数，要保证尽可能小），然后互换位置，最后进行升序排列。

附上大佬的解析：

 图解：

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var nextPermutation = function(nums) {
    // 学习大佬的思路，写一个算法
    // 题意：123456 => 123465  123546 ... 654321
    // 例如：把数组[1,2,3,8,5,7,6,4 ] 看成整数12385764，找出下一个比他大的最小整数 
    // 先从后向前，找出相邻的是升序的元素 A[i] < A[j]，然后从j开始，向后找第一个比A[i]大的数A[K]，再然后A[i] 和 A[k] 位置互换，最后再从j开始，升序排列，得到下一个排列。
    const len = nums.length;
    let indexJ = 0, indexI = 0;
    // 从后向前 找出是升序的两个相邻位置indexI和indexJ
    for(let i = len; i >0; i--){
        if (nums[i-1] < nums[i]) {
            indexJ = i
            indexI = i - 1;
            break;
        }
    }
    // 从起始位置 indexJ 开始,找出 尽可能小的「大数」nums[j]，与前面的「小数」nums[i]交换。比如 123465，下一个排列应该把 5 和 4 交换而不是把 6 和 4 交换
    // 把i后面的数提出来排序，找出最小的大数bigNum
    const data = []
    for(let j = indexJ; j < len; j++) {
        data.push(nums[j])
    }
    // 升序排列，第一个大于nums[i]的就是最小的大数
    data.sort((a,b)=>a-b); 
    const bigNum = data.find(item=>nums[indexI] < item);
    for(let j = indexJ; j < len; j++) {
        if (nums[j] === bigNum) {
            changeVal(nums, indexI, j)
            break;
        }
    }
    // j位置后面开始升序排列
    for(let m = indexJ; m < len; m++) {
        for (let k = m + 1; k < len; k++) {
            if (nums[k] < nums[m]) {
                changeVal(nums, k, m)
            }
        }
    }
};

function changeVal(nums = [], i=0, j=0) {
    const temp = nums[j];
    nums[j] = nums[i];
    nums[i] = temp;
}

 10.最大子序和

• 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
• 示例：

  输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
  输出：6
  解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

解题思路：遍历，最大的和res初始值为nums[0]，之前的和sum为0，计算每个位置i，当前的值nums[i]与之前的和sum + nums[i]比较，再比较res和sum，得出当前最大和，以此内推得到最终结果res，就是最大子序和。

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    const len = nums.length;
    // 动态规划
    let sum = 0; // 和
    let res = nums[0]; // 结果
    for(let i=0;i<len;i++){
        sum = Math.max(nums[i] + sum, nums[i])
        res = Math.max(res, sum)
    }
    return res
};

 11.回文链表

• 请判断一个链表是否为回文链表。

• 示例 1:

  输入: 1->2
  输出: false

  示例 2:

  输入: 1->2->2->1
  输出: true

解题思路：先把链表的值存入数组中，再通过遍历数组，比较两端的值是否相等来判断。

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {boolean}
 */
var isPalindrome = function(head) {
    // 先把链表的值存入数组中，再通过遍历数组，比较两端的值是否相等来判断
    const data = []
    while(head !== null){
        data.push(head.val)
        head = head.next
    }
    console.log(data)
    const len = data.length;
    for(let i = 0, j = len - 1; i < j; i++, j--) {
        // 比较两端的值
        if(data[i] !== data[j]) {
            return false
        }
    }
    return true
};

 12.和为s的连续正数序列

• 输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

• 示例 1：

　　　　输入：target = 9

　　　　输出：[[2,3,4],[4,5]]

• 示例 2：

　　　　输入：target = 15

　　　　输出：[[1,2,3,4,5],[4,5,6],[7,8]]

解题思路：找中间值作为外层循环次数，再累加比较，大于则跳过，等于则从当前位置开始累加，得到一个累加的数组，再将此数组放入一个结果中。

/**
 * @param {number} target
 * @return {number[][]}
 */
var findContinuousSequence = function(target) {
    const result = [];
    // 思路：1.求出中间值：target/2 向上取整(Math.ceil())，再往后和肯定大于目标值了，所以只取中间值以下的
    const middle = Math.ceil(target / 2);
    // 从1开始累加
    for (let i = 1; i < middle; i++) {
        // 控制累加的次数
        for (let j = 2;; j++) {
            // 求出累加多次的和(求和公式)
            const total = (i + (i + j - 1)) * (j / 2);
            if (total > target) {
                break;
            } else if (total === target) {
                result.push(createArr(i, j))
                break;
            }
        }
    }
    return result;
};

function createArr(n, len) {
    let arr = new Array(len).fill(null), temp = [];
    arr[0] = n;
    arr = arr.map((item, index) => {
        if (item === null) {
            item = temp[index - 1] + 1; // 在上一项基础上加1
        }
        // 当前项的值暂存，作为下一项的基础
        temp.push(item)
        return item;
    });
    return arr;
}

持续更新中...

和为s的连续正数序列