leetcode刷题记录(更新中)

数字数组

1、给定一个排序数组，原地去掉重复数字（例[1,1,2]）
思路：两个指针问题
过程：我的解法是利用了indexOf只返回第一个
结果：做这道题时间较长，执行时间较长o(n)，没有注意到“排序数组”
排名靠前的解法：
1、利用了nums[i]与nums[j]交换，较巧妙
2、或者伪装成原地：

var result = Array.from(new Set(nums));
nums.splice(0,nums.length,...result);

https://leetcode-cn.com/explore/featured/card/top-interview-questions-easy/1/array/21/

---

2、两数组交集
思路：取交集题目，每发现一个数，两个集合都要减去这个数（splice等）
过程：两个数组分别splice，⚠️splice的前后依赖问题
结果：执行超过66.71%
排名前：
1、利用filter - true

var intersect = function(nums1, nums2) {
    return nums1.filter(el => {
        const idx = nums2.indexOf(el)
        if(idx != -1){
            nums2.splice(idx,1)
            return true
        }
    })
};

https://leetcode-cn.com/explore/featured/card/top-interview-questions-easy/1/array/26/

字符串

1、原地反转字符串数组（判错3-4次）
审题：原地、利用o(1)空间
注意点：注意中间停止位置，需要判断奇偶性吗？
思路：一个for循环，Math.floor(len/2)前后交换（绕过奇偶）
结果：执行时间较快 超过99%
其他题解：

1. ?利用数组交换两个数

var reverseString = function(s) {
     let i = 0
    let j = s.length - 1
    while (i < j) {
        [s[i],s[j]]=[s[j],s[i]]
        i++
        j--
    }
};

2. 直接s.reverse()，也是原地反转
   https://leetcode-cn.com/explore/featured/card/top-interview-questions-easy/5/strings/32/

2、返回字符串中唯一的字符，没有返回-1（判错3-4次）
审题：题目中对于完备性有明确指示返回-1，所以这里要考虑全面，输入为[]，输入为‘cc’等等情况（此处两次判错）
思路：利用前后的indexOf（第一次出现）的加和与字符串lengh的关系
注意点：一开始想当然前后indexOf相等，脑中要有图，仔细的画出“过程”
https://leetcode-cn.com/explore/featured/card/top-interview-questions-easy/5/strings/34/

3、有效的字母异位词（判错2次 - 马虎）
思路：利用indexOf和splice结合
结果：执行时间慢，1408ms。。。
其他题解：
1）⚠️利用正则：注意新建正则写法new RegExp(s[0],'g')；注意这一句s.length!=t.length，不添加则因为‘g’出错，但’g’可以加快判断速度。

var isAnagram = function(s, t) {
  var len=s.length
  for(var i=0;i<len;i++){
    if(s==t || s.length!=t.length) break;
    t=t.replace(new RegExp(s[0],'g'),"");        
    s=s.replace(new RegExp(s[0],'g'),"");
  }
  return s==t? true:false;
};

https://leetcode-cn.com/explore/featured/card/top-interview-questions-easy/5/strings/35/

链表

1、数组中的0移动到最后
过程(1h)：尝试用链表做题，removeNode时返回后一个节点
结果：做这道题时间较长，浏览器测试通过，提交不通过；练习了js的链表写法（实现新建链表、删除节点、链表转为数组等）

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function(nums) {
    if(nums.length === 0){return nums}
    // 将nums变成一个链表
    var nodeList = {};
    nodeList.head = new Node(nums[0]);
    for(var i=1; i<nums.length; i++){
        addNode(nodeList, nums[i]);
    }
    // 遍历链表，将0挪到最后
    var len = length(nodeList);
    var i = 0;
    var node = nodeList.head;
    while(node && i < len){
        if(node.n === 0){
            node = removeNode(nodeList , node);
            addNode(nodeList, 0);
        } else {
            node = node.next;
        }
        i++;
    }
    return fromListToArray(nodeList);
};

function Node(n){
    this.n = n;
    this.next = null;
}
function addNode(nodeList, n){
    var node = nodeList.head;
    while(node.next){
        node = node.next;
    }
    var newNode = new Node(n);
    node.next = newNode;
    return nodeList;
}

function length(nodeList){
    var i = 1;
    var node = nodeList.head;
    while(node.next){
        node = node.next;
        i++;
    }
    return i;
}

function removeNode(nodeList, removeNode){
    var node = nodeList.head;
    if(removeNode.n === node.n){
        nodeList.head = nodeList.head.next;
        return nodeList.head;
    } else {
        while(node.next){
            if(removeNode.n === node.next.n){
                if(node.next.next){
                    node.next = node.next.next;
                } else {
                    node.next = null;
                }
                return node.next;
            }
        }
    }
}
function fromListToArray(nodeList){
    var array = [];
    var node = nodeList.head;
    while(node){
        array.push(node.n);
        node = node.next;
    }
    return array;
}

https://leetcode-cn.com/problems/move-zeroes/submissions/