leecode算法题【链表】（一）

已于 2022-03-10 12:23:27 修改
阅读量343 收藏
点赞数
文章标签： leetcode 算法 javascript
于 2022-03-08 19:17:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44376200/article/details/123329088
版权

203移除链表元素

方法一：递归

var removeElements = function(head, val) {
    if (head === null) {
            return head;
    }
    head.next = removeElements(head.next, val);
    return head.val === val ? head.next : head;
};

var removeElements = function (head, val) {
  if (head == null) {
    return head;
  }
  head.next = removeElements(head.next, val);
  // 只需要考虑当前节点是否等于val值，如果当前节点等于val值，则返回当前节点的下一个节点，否则返回当前节点
  return head.val == val ? head.next : head;
};

方法二：迭代

链表常规解题法，创建dummy指针，通过判断当前指针的下一节点的值是否为val解题。 

var removeElements = function(head, val) {
    const dummyHead = new ListNode(0);
    dummyHead.next = head;
    let temp = dummyHead;
    while (temp.next !== null) {
        if (temp.next.val == val) {
            temp.next = temp.next.next;
        } else {
            temp = temp.next;
        }
    }
    return dummyHead.next;
};

var removeElements = function (head, val) {
  let dummyNode = new ListNode(-1);
  dummyNode.next = head;
  let p = dummyNode;
  while (p.next != null) {
    if (p.next.val == val) {
      // 如果遍历到的节点的值等于val值，则将当前节点的next指针指向当前指向的节点的下一个节点
      p.next = p.next.next;
    } else {
      p = p.next;
    }
  }
  return dummyNode.next;
};

var removeElements = function(head, val) {
    let newList = new ListNode(0,head)
    let cur = newList
    while(cur.next){
        if(cur.next.val == val){
            cur.next = cur.next.next
        }else{
            cur = cur.next
        }
    }
    return newList.next
};

var removeElements = function(head, val) {
    const ret = new ListNode(0, head);
    let cur = ret;
    while(cur.next) {
        if(cur.next.val === val) {
            cur.next =  cur.next.next;
            continue;
        }
        cur = cur.next;
    }
    return ret.next;
};

如果不用虚拟头结点：

var removeElements = function(head, val) {
    // 先跳过所有头结点
    while(head !== null && head.val === val) {
        head = head.next
    }
    if(head === null) {
        return head
    }
    pre = head
    // 之后正常遍历即可~
    while(pre !== null && pre.next !== null) {
        if(pre.next.val === val) {
            pre.next = pre.next.next
        }
        else {
            pre = pre.next
        }
    }
    return head
};

83删除排序链表中的重复元素

不需要使用虚拟头结点

var deleteDuplicates = function(head) {
    let cur = head
    while(cur !== null && cur.next !== null) {
        if(cur.val === cur.next.val) {
            // 当前值与下一个值相同则 通过修改链表结点指向跳过这个值
            cur.next = cur.next.next
        }
        else {
            // 当前值与下一个值不相同则 结点继续移动 检查接下来的结点
            cur = cur.next
        }
    }
    return head
};

206&剑指offer24反转链表

方法一：迭代

时间复杂度：O(n)，其中n是链表的长度，需要遍历链表一次
空间复杂度：O(1)

var reverseList = function(head) {
    let prev = null;
    let curr = head;
    while (curr) {
        const next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
};

加一个为空的特殊情况，执行时间会少很多。

var reverseList = function(head) {
   if (head === null || head.next === null) return head;
   let prev = null;             // 定义一个前驱节点
   let cur = head;              // 定义一个当前节点
   while (cur) {
       let next = cur.next;     // 定义一个后继节点
       // 执行交换操作
       cur.next = prev;
       prev = cur;
       cur = next;
   }
   return prev;
};

方法二：递归

时间复杂度：O(n)，其中n是链表的长度，需要遍历链表一次
空间复杂度：O(n)

var reverseList = function(head) {
    if (head == null || head.next == null) {
        return head;
    }
    const newHead = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return newHead;
};

var reverseList = function(head) {
    if (head == null || head.next == null) return head
    const p = reverseList(head.next)
    head.next.next = head
    head.next = null
    return p
};

方法三：ES6语法

var reverseList = function(head) {
    /* 
        类比思考 反转数组思路 双端指针实现
        while (l < r) swap(a, l++, r--)
        数组位置的交换是这样 [a[i], a[j]] = [a[j], a[i]]
        但是 单链表只能依次通过 next 访问 不能通过索引访问 
        链表的交换需要扩展一个指针 即next
        cur 当前项
        prev 上一项
        cur.next 当前指针指向
        [ cur.next, prev, cur ] = [prev, cur, cur.next]
        上面这段ES6语法表示
        当前cur 的指针next 指向prev上一项 并且 交换迭代prev 和 next
    */
    let [p, c] = [null, head]

    while (c) [c.next, p, c] = [p, c, c.next]

    return p
};

141环形链表

方法一：快慢指针

「Floyd 判圈算法」（又称龟兔赛跑算法）：我们可以根据上述思路来解决本题。具体地，我们定义两个指针，一快一满。慢指针每次只移动一步，而快指针每次移动两步。初始时，慢指针在位置head，而快指针在位置head.next。这样一来，如果在移动的过程中，快指针反过来追上慢指针，就说明该链表为环形链表。否则快指针将到达链表尾部，该链表不为环形链表。
观察下面的代码，我们使用的是 while 循环，循环条件先于循环体。由于循环条件一定是判断快慢指针是否重合，如果我们将两个指针初始都置于 head，那么 while 循环就不会执行。因此，我们可以假想一个在 head 之前的虚拟节点，慢指针从虚拟节点移动一步到达 head，快指针从虚拟节点移动两步到达 head.next，这样我们就可以使用 while 循环了。
时间复杂度：O(n)
空间复杂度：O(1)

var hasCycle = function(head) {
    if(head==null||head.next==null){return false;}
    let fast=head.next;
    let slow=head;
    while(fast!=slow){
        if(fast==null||fast.next==null){return false;}
        slow=slow.next;
        fast=fast.next.next;
    }
    return true;
};

var hasCycle = function(head) {
  // 快慢指针初始化指向 head
  let slow = head;
  let fast = head;
  // 快指针走到末尾时停止
  while (fast && fast.next) {
    // 慢指针走一步，快指针走两步
    slow = slow.next;
    fast = fast.next.next;
    // 快慢指针相遇，说明含有环
    if (slow == fast) {
      return true;
    }
  }
  // 不包含环
  return false;
};

方法二：哈希表

时间复杂度：O(n)
空间复杂度：O(n)

var hasCycle = (head) => {
    let map = new Map();
    while (head) {
        if (map.has(head)) return true;//如果当前节点在map中存在就说明有环
        map.set(head, true);//否则就加入map
        head = head.next;//迭代节点
    }
    return false;//循环完成发现没有重复节点，说明没环
};

方法三：巧用JS

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

142环形链表II

方法一：快慢指针

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

var detectCycle = function(head) {
    if (head === null) {
        return null;
    }
    let slow = head, fast = head;
    while (fast !== null) {
        slow = slow.next;
        if (fast.next !== null) {
            fast = fast.next.next;
        } else {
            return null;
        }
        if (fast === slow) {
            let ptr = head;
            while (ptr !== slow) {
                ptr = ptr.next;
                slow = slow.next;
            }
            return ptr;
        }
    }
    return null;
};

var detectCycle = function(head) {
    if(head==null||head.next==null){return null;}
    let fast=head;
    let slow=head;
    while(fast&&fast.next){
        fast=fast.next.next;
        slow=slow.next;
        if(fast==slow){
            let ptr=head;
            while(ptr!=slow){
                ptr=ptr.next;
                slow=slow.next;
            }
            return ptr;
        }
    }
    return null;
};

var detectCycle = function(head) {
  // 快慢指针初始化指向 head
  let slow = head;
  let fast = head;
  // 快指针走到末尾时停止
  while (fast && fast.next) {
    // 慢指针走一步，快指针走两步
    slow = slow.next;
    fast = fast.next.next;
    // 快慢指针相遇，说明含有环
    if (slow == fast) {
      // 任一一节点指向头节点
      fast = head;
      // 同步向前进
      while (fast != slow) {
        fast = fast.next;
        slow = slow.next;
      }
      // 返回入口节点
      return fast;
    }
  }
  // 不包含环
  return null;   
};

方法二：哈希表

时间复杂度：O(n)
空间复杂度：O(n)

var detectCycle = function(head) {
    const visited = new Set();
    while (head !== null) {
        if (visited.has(head)) {
            return head;
        }
        visited.add(head);
        head = head.next;
    }
    return null;
};

剑指offer22链表中倒数第k个节点

方法一：顺序查找

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

var getKthFromEnd = function(head, k) {
    let node = head, n = 0;
    while (node) {
        node = node.next;
        n++;
    }
    node = head;
    for (let i = 0; i < n - k; i++) {
        node = node.next;
    }
    return node; 
};

方法二：快慢指针

时间复杂度：O(n)
空间复杂度：O(1)
应该考虑的特殊情况有：
head为空指针；
k大于链表的长度；
输入的参数k为0；

var getKthFromEnd = function(head, k) {
    let fast=head;
    let slow=head;
    for(let i=0; i<k; i++){
        fast=fast.next;
    }
    while(fast){
        slow=slow.next;
        fast=fast.next;
    }
    return slow;
};

var getKthFromEnd = function(head, k) {
    let fast = head, slow = head;
    
    while (fast && k > 0) {
        [fast, k] = [fast.next, k - 1];
    }
    while (fast) {
        [fast, slow] = [fast.next, slow.next];
    }
    return slow;
};
susunn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode分类-recordLCalgorithm:记录做过的LeeCode算法题
06-30
双指针技术是算法中的一种常见技巧，常用于处理数组或链表问题。通常情况下，一个指针从数组的一端开始，另一个指针从另一端开始，然后逐步向中间移动，直到满足某个条件为止。在LeetCode的26. 删除排序数组中的重复...
力扣算法之链表
qq_43569680的博客
03-25 503
链表 基本概念 链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口节点称为链表的头结点也就是head。 链表类型 单链表（上述就是单链表）：每个节点只有一个指针域，节点只能指向节点的下一个节点 双链表（每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点），既可以向前查询也可以向后查询 循环链表（链表首尾相连）：用来解决约瑟夫环问题 约瑟夫环问题：
LeetCode刷题------链表
weixin_43526403的博客
01-26 311
跟着代码随想录学链表
JS数据结构和算法
m0_46403734的博客
05-07 1219
一、深度优先遍历 const graph = { 0: [1, 2], 1: [2], 2: [0, 3], 3: [3] }; const res = []; const dfs = (n) => { console.log(n); //2 0 1 3 res.push(n); graph[n].forEach(item => { // 如果找不到该元素，它将返回-1 if (res.indexOf(it
【代码随想录 | day03】(JavaScript)链表理论基础&203.移除链表元素、707.设计链表、206.反转链表
qq_50722269的博客
11-19 198
【代码随想录 | day03】(JavaScript)链表理论基础&203.移除链表元素、707.设计链表、206.反转链表
算法-链表
qq_48192192的博客
11-01 218
链表链表理论基础链表的类型单链表双链表循环链表链表的存储方式链表的操作删除节点添加节点数组和链表移除链表元素 链表理论基础 链表是一种通过指针串联在一起的线性结构，每个节点由两部分组成，一个是数据域，一个是指针域（存放指向下一个节点的指针）。 最后一个节点的指针指向null（空指针）。 链接的入口点称为列表的头结点也就是head。 链表的类型 单链表 单链表中的节点只能指向节点的下一个节点。 双链表 每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。 双链表 既可以向前查询也可以向后查询。
LeeCode:算法代码
03-13
请你将两个数相加，并以相同形式返回一个表示和的链表。 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 无重复字符的最长子串（LongthOfLongestSubstring） 给定一个字符串，请您发现其中...
算法：leecode
03-04
LeetCode是一个著名的在线平台，提供了大量的算法题目，旨在帮助程序员提升算法能力和编程技巧。本文将针对Java语言，深入探讨LeetCode中的算法题目，为你的刷题之路提供详尽的指导。 一、基础数据结构 1. 数组：...
算法注释：Leecode刷题笔记
02-24
《算法注释：Leecode刷题笔记》是针对编程爱好者和面试准备者的宝贵资源，主要涵盖了一系列关于算法的深入解析和实战应用。这个压缩包文件"algorithm-notes-main"包含了作者在刷LeetCode题目时积累的笔记，这些笔记...
cpp代码-Leecode必刷题
07-14
总结一下，"cpp代码-Leecode必刷题"是一个专注于C++编程技能提升的项目，通过解决LeetCode上的问题，开发者可以加深对C++语言的理解，磨练算法技巧，并提高解决实际问题的能力。`main.cpp`文件包含了具体实现，而`...
java中new ListNode(0)常见用法详细区别（全）
码农研究僧的博客
06-21 9424
链表代码中常见用法区别： 一般此代码用在没有头结点或者需要双指针遍历等情况 1.初始化一个空节点，没有赋值，指针指向为list （不推荐） ListNode list = new ListNode(); 2.初始化一个空节点，初始赋值为0，指针指向为list ListNode list = new ListNode(0); 3.初始化一个空节点，初始赋值为0，并且list的下一个next指针指向head，指针指向为list ListNode list = new ListNode(0,head); 4
LeetCode算法题高频整理(精华篇)
Miracle8070
08-15 7935
1. 写在前面 之前刷题的时候，尝试把自己刷过的LeetCode算法题分类整理成了一个专栏算法刷题笔记，大约用14篇文章把算法题进行分类整理概括及总结，目前大约400道题目，本来想着秋招面试准备就反复刷这些就好，基本上能拿下80%的面试题。 但是发现400道量还是太多了，有很多刷过还总是忘，特别是数字找规律的那种， 并且我通过准备发现， 其实最常考和必会的并没有这么多， 面试官也是人呐， 考的肯定是他会的题目， 而太复杂的我们也都懂得哈哈。 所以这篇博客是整理在准备秋招面试刷题过程中，感觉出现的一些高频算法
移除链表元数
qq_43517257的博客
10-10 202
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next.
C++ 链表ListNode list=new ListNode() ，ListNode list=new ListNode(0) 与 ListNode list=null 的区别
关注大家关注我
11-13 5487
ListNode list=new ListNode() 上面代码初始化一个空节点，没有值，接下来需要给他进行赋值。 ListNode list=new ListNode(0) 上面代码初始化一个节点值为0的空节点，比较方便简洁。 ListNode list=null 上面代码定义一个空链表。 ...
【JAVA数据结构】经典链表面试题（附超详细代码注释和图解）
潘潘的博客
11-21 556
文章目录1、反转单链表2、给定一个带有头结点 head 的非空单链表，返回链表的中间结点3、输入一个链表，输出该链表中倒数第k个结点4、将两个有序链表合并为一个新的有序链表并返回5、分割链表6、删除该链表中重复的结点，重复的结点不保留7、 链表的回文结构8、输入两个链表，找出它们的第一个公共结点。9、给定一个链表，判断链表中是否有环。10、 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 1、反转单链表 题目介绍： 具体效果图如下： 思路分析： 1、首先设置两个指针，cu
LeetCode206: 反转链表（js）
star094606的博客
11-19 161
题目： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 解决： /* * @lc app=leetcode.cn id=206 lang=javascript * * [206] 反转链表 */ // @lc code=start /** * Definition for singl
ListNode list=new ListNode() 、 ListNode list=new ListNode(0) 与 ListNode list=null 的区别
weixin_41845265的博客
08-20 1923
ListNode list=new ListNode() 初始化一个空节点，无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的空节点，最常用最正规写法 ListNode list=null 为空，什么都没有，一般不这么写；
Leetcode 算法题合集
19年的墨先生的博客
07-29 2417
Leetcode 算法
leecode算法小抄
最新发布
06-25
Leetcode算法小抄是一份权威的算法手册，包含了Leetcode上常见的算法题目的解法和详细讲解。这个小抄对于想要提升自己算法能力的程序员来说非常有用。该小抄包括以下内容： 1.基础数据结构：包括数组、链表、栈、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值