JS-leetcode刷题-链表篇

leetcode算法 专栏收录该内容
2 篇文章 0 订阅

二、链表篇

leetcode-21--合并两个有序链表

Question:将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。(l1 和 l2 均按 非递减顺序 排列)

示例:

    输入:l1 = [1,2,4], l2 = [1,3,4]
    输出:[1,1,2,3,5,4]

Method 1:递归

思路:已知两个升序的链表

数据结构:单链表

使用递归前,最好做一个建模

  • l1[0]+merge(l1[1:],l2),l1[0]<l2[0]
  • l2[0]+merge(l1,l2[1:]),otherwise

边界情况:

  • l1 和 l2 都为空
  • l1 或 l2 为空

为了能够更好地理解递归的过程,把链表对象键值对的形式写出来

const l1 = {
    val: 1,
    next: {
        val: 2,
        next: { val: 4, next: null },
    },
};

const l2 = {
    val: 1,
    next: {
        val: 3,
        next: { val: 4, next: null },
    },
};

基于此我们再看代码...

// 我们需要辅助链表 =》 构造链表
const ListNode = function (val, next) {
    this.val = val || 0;
    this.next = next || null;
}

const mergeTwoLists = (l1, l2) => {
    // 递归函数
    const recursion = (newListNode, l1, l2) => {
        // 1 如果链表 l1 l2 都为空,那就结束本次递归
        if (!l1 && !l2) {
            return;
        }
        // 2 如果 l1 或 l2 链表为空,将非空连接加到新链表后面,也结束本次递归
        if (!l1 || !l2) {
            newListNode.next = l1 || l2;
            return;
        }
        // 3 再创建一个辅助链表,用来获取新链表的下一个新节点
        // 这里配合点 4 来看比较容易懂
        newListNode.next = new ListNode();
        newListNode = newListNode.next;

        // 4 排序,同时将采纳了的链表往后挪一位
        if (l1.val >= l2.val) {
            newListNode.val = l2.val;
            l2 = l2.next;
        } else {
            newListNode.val = l1.val;
            l1 = l1.next;
        }
        // 5 继续下一次递归
        recursion(newListNode, l1, l2);
    };

    // 初始化一个新链表(作为结果链表)
    const newListNode = new ListNode();
    // 处理这个链表,和 l1、l2
    recursion(newListNode, l1, l2);
    // 返回结果链表
    return newListNode.next; // 重点:我们初始化的时候,有一个没用的链表,记得往后挪一位
};

  通过上面的递归解法,我们理清思路后,可以优化递归的代码:

const mergeTwoLists = function (l1, l2) {
    if (l1 === null) {
        return l2;
    } else if (l2 === null) {
        return l1;
    } else if (l1.val < l2.val) {
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
};

时空复杂度:O(n + m)


Method 2:迭代 + 双指针

思路很像递归的思路:

  • 初始化一个新链表
  • 归并排序
const ListNode = function (val, next) {
    this.val = val || 0;
    this.next = next || null;
}
const mergeTwoLists = function (l1, l2) {
    const prehead = new ListNode(); // 创建一个哨兵节点(链表)
    let prev = prehead; // 初始化指针 prev 指向哨兵节点
    while(l1 && l2) {
        if(l1.val <= l2.val) {
            prev.next = l1; // 这里同时改变了 prehead.next, prev 仅仅是辅助指针
            l1 = l1.next;
        } else {
            prev.next = l2;
            l2 = l2.next;
        }
        prev = prev.next; // 将辅助指针 prev 移动到下一位(当前的 prehead.next)
    }
    prev.next = l1 || l2; // 合并后 l1 和 l2 最多只有一个还未被合并完,我们直接通过指针将链表的末尾指向未合并完的链表即可
    return prehead.next; // 返回哨兵节点(链表)之后的所有节点
};

时间复杂度:O(n + m),空间复杂度:O(1)

leetcode-141--环形链表

Question:给定一个链表,判断链表中是否有环。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。

如果链表中存在环,则返回 true 。 否则,返回 false 。

进阶:

你能用 O(1)(即,常量)内存解决此问题吗?

Method 1:暴力法

思路:

  • cur1 每遍历到一个节点,就让 cur2 从头遍历之前所有节点
  • 如果 cur2 走到 cur1,所用的步数二者一样,则相遇点不是入环点
  • 如果 cur2 走到 cur1,用的步数二者不一样,则相遇点是入环点,cur1比 cur2多走一个环
  • 时间复杂度为 O(n^2),空间复杂度为 O(1)
const hasCycle = (head) => {
    let cur1 = head; // cur1指针指向链表节点
    let step1 = 0; // 初始化cur1指针走的步数
    while (cur1) {
        step1++; // 走一步
        let cur2 = head; // 然后创建cur2指针开始从头遍历
        let step2 = 0; // 初始化cur2指针走的步数
        while (cur2) {
            step2++; // 走一步
            if (cur1 == cur2) { // cur1和cur2的元素相同
                if (step1 == step2) { // 如果走的步数一样,即走到了cur1这里
                    break; // 退出内层while
                } else {  // 相遇但步数不一样
                    return true; // cur2多走了几步(一个环)又回到了cur1,说明链表有环
                }
            }
            cur2 = cur2.next; // cur2向后移动一步
        }
        cur1 = cur1.next; // cur1向后移动一步
    }
    return false;
};

Method 2:利用 JSON.stringify() 不能序列化含有循环引用的结构

const hasCycle = function(head) {
    try{
        JSON.stringify(head);
        return false;
    }
    catch(err){
        return true;
    }
};

时间复杂度:O(n),空间复杂度:O(n)

Method 3:标志法

给每个已遍历过的节点加标志位,遍历链表,当出现一个节点已被标志时,则证明单链表有环

const hasCycle = function(head) {
    while(head) {
        if(head.flag) return true
        head.flag = true
        head = head.next
    }
    return false
};

时间复杂度:O(n),空间复杂度:O(n)

emmmm,这个方法写的总感觉哪里不对劲,虽然能顺利通过。(head.flag哪来的?这么添加属性真的可以嘛?你品,你细品)

顺便附上题目定义的链表节点

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {boolean}
 */

Method 4:哈希表

思路:参考标志法的思路

  • 哈希表存遍历过的节点,每遍历一个节点,都查看哈希表是否存在当前节点,如果存在,则说明链表有环
  • 如果不存在,则存入哈希表,继续遍历
  • 时间复杂度为 O(n),空间复杂度为 O(n)
const hasCycle = (head) => {
    let map = new Map();
    while (head) {
        if (map.has(head)) return true;
        map.set(head, true); // 存的是节点的地址引用,而不是节点值
        head = head.next;
    }
    return false;
};

Method 5:快慢指针(双指针法)

思路:类似 “追及问题”

两个人在环形跑道上赛跑,同一个起点出发,一个跑得快一个跑得慢,在某一时刻,跑得快的必定会追上跑得慢的,只要是跑道是环形的,不是环形就肯定追不上。

  • 快、慢指针,从头节点出发
  • 慢指针每次走一步,快指针每次走两步,不断比较它们指向的节点的值
  • 如果节点值相同,说明有环。如果不同,继续循环。
const hasCycle = (head) => {
    let fast = head;
    let slow = head;
    while (fast) {
        if (fast.next == null) return false;
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) return true;
    }
    return false;
}

时间复杂度:O(n),空间复杂度:O(1)

leetcode-206--反转链表

Question:给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

示例:

    输入:head = [1,2,3,4,5]
    输出:[5,4,3,2,1]

进阶:链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 



​    

 

 

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:1024 设计师:我叫白小胖 返回首页

打赏作者

huohuoit

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值