2024秋招前端笔试刷题记录第一周！！

如果你也跟我一样刚刚开始准备秋招笔试  那么一起加油吧  我会不定时记录自己的刷题经历  

刚开始做的题简单一点 找回一点做算法题的感觉  希望笔试会出现

1.合并后两个有序数组（双指针）（简单）

 

思路就是给两个数组定义两个指针，分别指向两个尾部，并且从尾部开始比较大小，哪个大就插入到nums1的尾部，直到有一个指针指向0。

如果nums1的指针指向0，那么说明num2剩下的元素都比num1的元素要小，所以需要把nums2的剩余的元素插入到nums1指针的k之前。

如果是nums2的指针指向0，就说明nums2的元素处理完毕了，已经合并完毕了，那么就可以结束了

 

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
var merge = function (nums1, m, nums2, n) {
    let i = m - 1;
    let j = n - 1;
    let k = m + n - 1;
    while (i >= 0 && j >= 0) {
        if (nums1[i] >= nums2[j]) {
            nums1[k] = nums1[i];
            k--;
            i--;
        } else {
            nums1[k] = nums2[j];
            k--;
            j--;
        }
    }
    while (j >= 0) {
        nums1[k] = nums2[j];
        k--;
        j--;
    }

};

2.两数之和（map）（简单）

这题的思路是这样的，由于题目需要比较的是值，输出的是索引，因为我们选择用map来操作。

在我们遍历的时候，如果target-第一个数作为键值，在map中找到了，说明在map中是有一个值+现在遍历的当前值 = target，那么就可以返回当前值的索引，以及在map中找到那个数的索引。

否则的话，我们就将当前值作为键值，索引作为值，存入map里面。原理就是通过map可以存储键值对，而结果又要返回索引，比较的话通过map的get和set来判断是否某个值存在于map中，从而来返回其索引的值。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function (nums, target) {

    // 假设一个数组为[2,3,-1,2] target 为4

    let map = new Map();
    for (let i = 0; i < nums.length; i++) {
        if (map.get(target - nums[i]) != undefined) {  //如果这个差值作为键值找不到的话
            return [i, map.get(target - nums[i])]   //否则就返回当前索引和找到的索引
        } else { //就将这个值作为键值，索引作为值存到map里
            map.set(nums[i], i)
        }
    }
};

3.三数之和（双指针）（中等）

这题主要的思路其实和两数之和类似，只不过将target的值变成了动态的 然后使用了双指针

那么当我们要使用双指针的时候，其数组必须是有序的，这样我们才能合理地去缩小范围来比较，

同时避免有相同值的情况，避免冗余比较

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function (nums) {
    let len = nums.length;
    nums = nums.sort((a,b)=>
        a-b
   );//使用双指针先确保其是有序的 a-b为递增
    let numbers = []
    for (let s = 0; s < len - 2; s++) {
        let l = s + 1;
        let r = len - 1;
        //s为target指针 指向target的值  每次s++都判断 是否和前一个target一样，如果一样 那么就下一此循环判断
        if (s > 0 && nums[s] == nums[s - 1]) {
            continue;
        }
        //比较三者之和，如果大于0 说明右指针的值大了，那么右指针--；如果小于0，说明左指针小了，那么左指针++
        //并且每次指针变化后，都要判断是否和上一个值相同，如果相同的话，那么继续变化。
        while (l < r) {
            if (nums[s] + nums[l] + nums[r] > 0) {
                r--;
                while (nums[r] == nums[r + 1] && r > l) {
                    r--;
                }
            } else if (nums[s] + nums[l] + nums[r] < 0) {
                l++;
                while (nums[l] == nums[l - 1] && r > l) {
                    l++;
                }
            }
            else {
                numbers.push([nums[s], nums[l], nums[r]])
                l++;
                r--;
                while (nums[l] == nums[l - 1] && r > l) {
                    l++;
                }
                while (nums[r] == nums[r + 1] && r > l) {
                    r--;
                }
            }
        }

    }

    return numbers

};

4.验证回文串（递归，翻转字符串）（简单）

使用js最简单的方法，就是先将其不是字母，数字，下划线，汉字的的字符替换为空，然后反转其字符串看是否和原来的一致。

/**
 * @param {string} s
 * @return {boolean}
 */
var isPalindrome = function (s) {
    s = s.replace(/[\W_]/g, '').toLowerCase();
    var reverseStr = s.split('').reverse().join('');
    return s === reverseStr;
};

递归的写法

function palindrome (str) {
 // 删除字符串中不必要的字符
 var re = /[\W_]/g;
 // 将字符串变成小写字符
 var lowRegStr = str.toLowerCase().replace(re, '');
 // 如果字符串lowRegStr的length长度为0时，字符串即是palindrome
 if (lowRegStr.length === 0) {
 return true;
 }
 
 // 如果字符串的第一个和最后一个字符不相同，那么字符串就不是palindrome
 if (lowRegStr[0] !== lowRegStr[lowRegStr.length - 1]) {
 return false;
 } else {
 return palindrome(lowRegStr.slice(1, lowRegStr.length - 1));
 }
}

5.添加与搜索单词（正则+二维数组）（中等）

这个题要注意的就是 存储的时候是用单词的长度作为数组的索引存储，

相当于word = [ [1], [2] , [3] , [4] ] 而 word[4]=['word','aaaa']

然后创建一个正则表达式如果单词包含.的话，用这个正则表达式调用test来看在存储的单词是否有满足的，如果有的话那么就返回为true

var WordDictionary = function () {
    this.words = []
};

/** 
 * @param {string} word
 * @return {void}
 */
WordDictionary.prototype.addWord = function (word) {
    //根据单词的长度来作为索引存储 那么搜索的时候第一步先看这个长度的单词有没有
    //其次看这个长度的单词的数组是否包含搜索的单词
    let len = word.length
    if (this.words[len] == undefined) {
        this.words[len] = [word]
    } else {
        this.words[len].push(word)
    }
};

/** 
 * @param {string} word
 * @return {boolean}
 */
WordDictionary.prototype.search = function (word) {
    const len2 = word.length
    //如果搜索的这个长度没有保存单词，说明搜索的单词不存在
    if (this.words[len2] == undefined) {
        return false
    }
    //如果不包含点的话 那么久直接用include判断保存的数组里是否有这个单词
    if (!word.includes('.')) {
        return this.words[len2].includes(word)
    }
    //否则包含.，那么就通过创建一个正则规则就是这个单词，例如.ad，规则就是以.开头并且有ad的单词
    let reg = new RegExp(word)
    //看看是否有任意单词满足这种情况
    //注意这里正则规则的用法 是创建一个正则对象然后传入字符串看是否满足规则
    if (this.words[len2]) {
        return this.words[len2].some(i => reg.test(i))
    }
};