咨询热线 ：
028-86922220
×
01
关于我们

公司简介

发展历程

02
服务项目

高端网站建设

微信开发

APP开发

网络营销服务

电商网站定制

生物医药网站建设

外贸网站建设

教育培训网站建设

03
小程序开发

小程序开发

功能应用

客户案例

04
案例展示

网站建设案例

小程序案例

电商平台案例

APP案例

系统平台案例

05
建站动态

网站建设

网站设计

网站营销

小程序

06
联系我们

公司地址

人才招聘

地址：成都市太升南路288号锦天国际A幢1002号

电话：028-86922220

028-86922220

大橙子网站建设，新征程启航

为企业提供网站建设、域名注册、服务器等服务

前端也该刷点算法题——双指针解“链表”题也太香了叭！

双指针解“链表”题也太香了叭！

同步双指针

1 查找链表中倒数第 k 个节点

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

在网站设计制作、网站设计过程中，需要针对客户的行业特点、产品特性、目标受众和市场情况进行定位分析，以确定网站的风格、色彩、版式、交互等方面的设计方向。创新互联公司还需要根据客户的需求进行功能模块的开发和设计，包括内容管理、前台展示、用户权限管理、数据统计和安全保护等功能。

思路：

  1. 假设链表的长度为n，不难得出倒数第k个节点即为整数第n + 1 - k。

  2. 如果一个指针从头节点开始走k步（头节点算作第1步），则还需n + 1 - k步才能走完链表（到达尾节点的next，即 null）。

  3. 我们用双指针，一个指针先走k步，然后两个指针同时走n + 1 - k步，其中一个指针走完链表，另一个指针走到第n + 1 - k个节点处，即倒数第k个节点

代码

JS

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var getKthFromEnd = function (head, k) {
  let p1 = head;
  // 注意此处 i < k - 1，因为 p1 赋值时算作第 1 步
  for (let i = 0; i < k - 1; i++) {
    p1 = p1.next;
  }

  let p2 = head;
  p1 = p1.next; // 同理 p2 赋值算作第 1 步，所以 p1 也要走 1 步
  while (p1) {
    p1 = p1.next;
    p2 = p2.next;
  }

  return p2;
};

// 时间复杂度 O(n) n为链表长度
// 空间复杂度 O(1)

TS

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

function getKthFromEnd(head: ListNode | null, k: number): ListNode | null {
  const dummyHead = new ListNode();
  dummyHead.next = head;
  let p1 = dummyHead;
  for (let i = 0; i < k; i++) {
    p1 = p1.next;
  }

  let p2 = dummyHead;
  while (p1) {
    p1 = p1.next;
    p2 = p2.next;
  }

  return p2;
}

// 时间复杂度 O(n) n为链表长度
// 空间复杂度 O(1)

注：JS 和 TS 的实现略微有些不同，TS 中添加了一个虚拟头节点，虚拟头节点在解决链表相关的一些题目时非常有用，体会一下不用虚拟头节点和使用虚拟头节点的差别

2 删除链表中倒数第 k 个节点

19.删除链表的倒数第N个结点

思路

  1. 删除和查找倒数第 k 个节点的思路大致相同

  2. 唯一的区别是删除倒数第 k 个节点时我们应该查找倒数第 k + 1 个节点，然后让其 next 指向 next 的 next。

    因为我们要查找倒数第 k + 1 个节点，所以应该让第一个指针先走 k + 1 步

  3. 此外删除的有可能是第 1 个节点，见示例2，此时删除的是倒数第 1 个节点，所以我们要查找倒数第 2 个节点，然而链表总共才 1 个节点，因此我们引入虚拟头节点来解决

代码

JS

var removeNthFromEnd = function (head, n) {
  const dummyHead = new ListNode();
  dummyHead.next = head; // 将虚拟头节点接入链表

  let p1 = dummyHead;
  // p1 先走 n + 1 步
  for (let i = 0; i < n + 1; i++) {
    p1 = p1.next;
  }
  let p2 = dummyHead;
  while (p1) {
    p1 = p1.next;
    p2 = p2.next;
  }
  p2.next = p2.next.next;

  // 注意不是返回 head，因为 head 有可能被删除
  return dummyHead.next;
};

// 时间复杂度 O(n) n为链表长度
// 空间复杂度 O(1)

TS

function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
  const dummyHead = new ListNode();
  dummyHead.next = head;
  let p1 = dummyHead;
  for (let i = 0; i < n + 1; i++) {
    p1 = p1.next;
  }
  let p2 = dummyHead;
  while (p1) {
    p1 = p1.next;
    p2 = p2.next;
  }
  p2.next = p2.next.next;
  return dummyHead.next;
}

注：尝试不用虚拟头节点解此题，体会虚拟头节点的妙处

3 查找两条链表的相交节点

160. 相交链表

思路

  1. 双指针 p1 和 p2 分别从 headA 和 headB 出发
  2. 如果 p1 走完了链表 A，就从 headB 接着走；同理，如果 p2 走完了链表 B，就从 headA 接着走
  3. 在这种走法下，p1 和 p2 一定同时走完
  4. 如果两条链表相交，那么 p1 和 p2 一定会在交点相遇，因为从交点开始到结束点，两条链表的路径是相同的，于是 p1 和 p2 从结束点向前推能同时到达交点
  5. 如果两条链表不相交，则 p1 和 p2 全程不会相遇

代码

JS

var getIntersectionNode = function (headA, headB) {
  let p1 = headA;
  let p2 = headB;

  while (p1 || p2) {
    if (p1 === p2) return p1;
    p1 = p1 ? p1.next : headB;
    p2 = p2 ? p2.next : headA;
  }

  return null;
};

// 时间复杂度 O(n + m) m、n 分别为两条链表长度
// 空间复杂度 O(1)

TS

function getIntersectionNode(
  headA: ListNode | null,
  headB: ListNode | null
): ListNode | null {
  let p1 = headA;
  let p2 = headB;

  while (p1 || p2) {
    if (p1 === p2) return p1;
    p1 = p1 ? p1.next : headB;
    p2 = p2 ? p2.next : headA;
  }

  return null;
}

快慢双指针

1 查找链表的中间节点

876. 链表的中间结点

思路

  1. 这题我们让两个指针同时走，不过两个指针的速度不同，分为快慢指针
  2. 我们让慢指针每次走 1 步，快指针每次走 2 步
  3. 当快指针走完链表，即指向 null，慢指针就走到了中间节点的位置

代码

JS

var middleNode = function (head) {
  const dummyHead = new ListNode();
  dummyHead.next = head;
  let fastP = dummyHead;
  let slowP = dummyHead;
  while (fastP) {
    slowP = slowP.next;
    fastP = fastP.next;
    fastP && (fastP = fastP.next);
  }
  return slowP;
};

// 时间复杂度 O(n) n 为链表长度
// 空间复杂度 O(1)

TS

function middleNode(head: ListNode | null): ListNode | null {
  const dummyHead = new ListNode();
  dummyHead.next = head;
  let fastP = dummyHead;
  let slowP = dummyHead;
  while (fastP) {
    slowP = slowP.next;
    fastP = fastP.next;
    fastP && (fastP = fastP.next);
  }
  return slowP;
}

2 判断链表中是否有环

141. 环形链表

思路

  1. 设定快慢两指针 fastP 、slowP
  2. fastP 每次走 2 步，slowP 每次走 1 步
  3. 如果链表中没有环，那么 fastP 最终会先走到 null
  4. 如果链表中有环，那么 fastP 会先进入环，并在环中转圈
  5. 当 slowP 进入环后，fastP 开始追赶 slowP，最终一定能追上
  6. 当 fastP 追上 slowP 时，若 slowP 走了 n 步，不难得出，fastP 走了 2n 步或 2n - 1 步

代码

JS

var hasCycle = function (head) {
  // 如果链表为空或只有 1 个节点，一定无环
  if (!head || !head.next) return false;

  let slowP = head;
  let fastP = head.next; // slowP 赋值为 head 相当于走了 1 步，故 fastP 要走 2 步
  while (fastP) {
    slowP = slowP.next;
    fastP = fastP.next;
    if (slowP === fastP) return true;
    fastP && (fastP = fastP.next);
  }
  return false;
};

// 时间复杂度 O(n) n 为链表长度
// 空间复杂度 O(1)

TS

function hasCycle(head: ListNode | null): boolean {
  if (!head || !head.next) return false;
  let slowP = head;
  let fastP = head.next;
  while (fastP) {
    slowP = slowP.next;
    fastP = fastP.next;
    if (slowP === fastP) return true;
    fastP && (fastP = fastP.next);
  }
  return false;
}

3 查找链表中环的入口节点

142. 环形链表 II

思路

  1. 此题和上一题的思路大致相同，不过在上一题的基础上更进一步
  2. 上一题中提到，如果快指针追上慢指针，且假设 slowP 走了 n 步，不难得出，fastP 走了 2n 步或 2n - 1 步。出现走 2n - 1 步的原因是可能存在 fastP 最后只走 1 步就追上 slowP 的情况
  3. 不过即使规定 fastP 一定要走偶数步，fastP 和 slowP 也一定能在某点相遇，因为在 fastP 走 2 步，slowP 走 1 步的前提下，两者的间距会 -1，所以最终两者会相遇
  4. 现在设 slowP 走了 n 步，fastP 走了 2n 步，两者相遇
  5. 则 fastP 比 slowP 多走了 n 步，这 n 步是环周长的整数倍
  6. 假设 slowP 从环起点开始走了 k 步后，两者相遇，则从链表头节点开始走 n - k 步（头节点算第 1 步）就能到达环起点
  7. 而从环起点走 k 步到达相遇点，再走 n - k 步就能到达相遇点，因为从环起点走 k + n - k = n 步回到环起点（见第5点，因为 n 是环周长的整数倍）
  8. 所以我们可以先用快慢指针找到两者的相遇点，然后让快指针从头开始，慢指针从相遇点开始，并且两者变成同步指针，则两者再次相遇即为环的起点

代码

JS

var detectCycle = function (head) {
  if (!head || !head.next) return null;
  let fastP = head.next;
  let slowP = head;
  while (fastP) {
    if (fastP === slowP) break;
    slowP = slowP.next;
    fastP = fastP.next;
    fastP && (fastP = fastP.next);
  }
  if (!fastP) return null;
  fastP = head;
  slowP = slowP.next; // 注意 fastP 赋值为头节点相当于已经走了 1 步，所以 slowP 也要走 1 步
  while (fastP !== slowP) {
    fastP = fastP.next;
    slowP = slowP.next;
  }
  return fastP;
};

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

TS

function detectCycle(head: ListNode | null): ListNode | null {
  // 这里我们把头节点当作虚拟节点
  let fastP = head;
  let slowP = head;
  while (fastP) {
    slowP = slowP.next;
    fastP = fastP.next;
    fastP && (fastP = fastP.next);
    if (fastP === slowP) break;
  }
  if (!fastP) return null;
  fastP = head;
  slowP = slowP;
  while (fastP !== slowP) {
    fastP = fastP.next;
    slowP = slowP.next;
  }
  return fastP;
}

注：我们在 TS 中把头节点当做了虚拟节点，体会两种解法的细微差别

总结

事实上，使用双指针的链表题还有很多，这里就举几个常见的栗子????，并且在链表题中虚拟头节点也是个很棒的技巧，有时可以减少很多额外的判断

完结撒花????

公众号【今天也要写bug】


新闻名称：前端也该刷点算法题——双指针解“链表”题也太香了叭！
URL地址：http://dzwzjz.com/article/dsojgpi.html

其他资讯

分享至：
关于我们
公司简介 发展历程
服务项目
高端网站建设 小程序开发 APP开发 网络营销
建站知识
行业新闻 建站学堂 常见问题
联系我们
公司地址 人才招聘
成都 达州
电话：028-86922220
地址：成都市太升南路288号锦天国际A幢1002号
电话：028-86922220
地址：达州市南岸区弹子石腾龙大道58号2栋21-6
友情链接： 注册域名   网站改版   成都外贸网站建设公司   成都网站建设   四川电信高防服务器托管   中国电信成都枢纽中心   顺泽窗帘   app网站建设   专业网站设计   成都网站制作   
版权所有：青羊区大橙子信息咨询工作室 蜀ICP备2022028542号-14
在线咨询
服务热线
服务热线：028-86922220
TOP