链表算法题

最新推荐文章于 2023-01-19 17:54:04 发布
置顶 最新推荐文章于 2023-01-19 17:54:04 发布
阅读量242 收藏 2
点赞数
分类专栏： 算法题 文章标签： 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdfunk/article/details/119464567
版权

链表相关算法题

206. 反转链表

206. 反转链表

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

示例 1：
在这里插入图片描述

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

迭代法

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode last=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return last;
    }
}

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

递归法

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
       ListNode pre=null;
       ListNode cur=head;
       
       while(cur!=null){
          ListNode next=cur.next;
           cur.next=pre;
           pre=cur;
           cur=next;
       }
       return pre;
    }
}

复杂度分析
时间复杂度：O(n)，其中 n是链表的长度。需要遍历链表一次。
空间复杂度：O(n),空间复杂度主要取决于递归调用的栈空间，最多为 n 层

92. 反转链表 II

92. 反转链表 II
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

方法一：穿针引线

我们以下图中黄色区域的链表反转为例。
在这里插入图片描述

使用「206. 反转链表」的解法，反转 left 到 right 部分以后，再拼接起来。我们还需要记录 left 的前一个节点，和 right 的后一个节点。如图所示：
在这里插入图片描述

算法步骤：
在这里插入图片描述

第 1 步：先将待反转的区域反转；
第 2 步：把 pre 的 next 指针指向反转以后的链表头节点，把反转以后的链表的尾节点的 next 指针指向 succ。

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode pre = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }

        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
        ListNode rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode.next;
        }

        // 第 3 步：切断出一个子链表（截取链表）
        ListNode leftNode = pre.next;
        ListNode curr = rightNode.next;

        // 注意：切断链接
        pre.next = null;
        rightNode.next = null;

        // 第 4 步：同第 206 题，反转链表的子区间
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre.next = rightNode;
        leftNode.next = curr;
        return dummyNode.next;
    }

    private void reverseLinkedList(ListNode head) {
        // 也可以使用递归反转一个链表
        ListNode pre = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/reverse-linked-list-ii/solution/fan-zhuan-lian-biao-ii-by-leetcode-solut-teyq/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法二：一次遍历（头插法）

方法一的缺点是：如果 left 和 right 的区域很大，恰好是链表的头节点和尾节点时，找到 left 和 right 需要遍历一次，反转它们之间的链表还需要遍历一次，虽然总的时间复杂度为 O(N)，但遍历了链表 2 次，可不可以只遍历一次呢？答案是可以的。
在这里插入图片描述
整体思想是：在需要反转的区间里，每遍历到一个节点，让这个新节点来到反转部分的起始位置。下面的图展示了整个流程。
在这里插入图片描述
使用三个指针变量 pre、curr、next 来记录反转的过程中需要的变量，它们的意义如下：

curr：指向待反转区域的第一个节点 left；
next：永远指向 curr 的下一个节点，循环过程中，curr 变化以后 next 会变化；
pre：永远指向待反转区域的第一个节点 left 的前一个节点，在循环过程中不变。

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 设置 dummyNode 是这一类问题的一般做法
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
        ListNode pre = dummyNode;
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }
        ListNode cur = pre.next;
        ListNode next;
        for (int i = 0; i < right - left; i++) {
            next = cur.next;
            cur.next = next.next;
            next.next = pre.next;
            pre.next = next;
        }
        return dummyNode.next;
    }
}

25. K 个一组翻转链表

25. K 个一组翻转链表

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

递归：
在这里插入图片描述

    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode tail = head;
        for (int i = 0; i < k; i++) {
            //剩余数量小于k的话，则不需要反转。
            if (tail == null) {
                return head;
            }
            tail = tail.next;
        }
        // 反转前 k 个元素
        ListNode newHead = reverse(head, tail);
        //下一轮的开始的地方就是tail
        head.next = reverseKGroup(tail, k);

        return newHead;
    }

    /*
    左闭又开区间
     */
    private ListNode reverse(ListNode head, ListNode tail) {
        ListNode pre = null;
        ListNode next = null;
        while (head != tail) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;

    }

.
.

迭代法
步骤分解:

  • 链表分区为已翻转部分+待翻转部分+未翻转部分
  • 每次翻转前，要确定翻转链表的范围，这个必须通过 k 此循环来确定
  • 需记录翻转链表前驱和后继，方便翻转完成后把已翻转部分和未翻转部分连接起来
  • 初始需要两个变量 pre 和 end，pre 代表待翻转链表的前驱，end 代表待翻转链表的末尾
  • 经过k此循环，end 到达末尾，记录待翻转链表的后继 next = end.next
  • 翻转链表，然后将三部分链表连接起来，然后重置 pre 和 end 指针，然后进入下一次循环
  • 特殊情况，当翻转部分长度不足 k 时，在定位 end 完成后，end==null，已经到达末尾，说明题目已完成，直接返回即可
  • 时间复杂度为 O(n*K)最好的情况为 O(n) 最差的情况未 O(n^2)
    空间复杂度为 O(1)除了几个必须的节点指针外，我们并没有占用其他空间
    在这里插入图片描述
public ListNode reverseKGroup(ListNode head, int k) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;

    ListNode pre = dummy;
    ListNode end = dummy;

    while (end.next != null) {
       for (int i = 0; i < k ; i++) {
            end = end.next;
            if(end==null){
                break;
            }
        }
        if (end == null) break;
        ListNode start = pre.next;
        ListNode next = end.next;
        end.next = null;
        pre.next = reverse(start);
        start.next = next;
        pre = start;

        end = pre;
    }

 //如果后面K个也需要翻转，在这里翻转，此时end=null,从pre后面开始翻转
      //  ListNode start=pre.next;
      //  pre.next=reverse(start);

    return dummy.next;
}

private ListNode reverse(ListNode head) {
    ListNode pre = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = pre;
        pre = curr;
        curr = next;
    }
    return pre;
}

作者：reals
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/tu-jie-kge-yi-zu-fan-zhuan-lian-biao-by-user7208t/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

拓展1：不足k个也要反转

k个一组反转链表，不足k个也要反转

在递归写法中，判断tail是否为空，tail为空，则break，后面翻转head到tail

        for (int i = 0; i < k; i++) {
            //剩余数量小于k的话，则break，后面翻转head到tail.
            if (tail == null) {
               // return head;
               break;
            }
            tail = tail.next;
        }

迭代写法里面：循环结束后，翻转后面剩余节点，见代码注释

拓展2：从尾部开始计数，k个一组翻转

从尾部开始计数，k个一组翻转，不足k个不翻转 比如：
输入：1->2->3->4->5, k = 2
输出：1->3->2->5->4

160. 相交链表

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode p1=headA;
        ListNode p2=headB;
       while(p1!=p2){
            if(p1==null){
                p1=headB;
            }else{
                p1=p1.next;
            }

            if(p2==null){
                p2=headA;
            }else{
                p2=p2.next;
            }
        }

        return p1;
    }

}

21. 合并两个有序链表

21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

拓展：考虑去重

递归

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        if(l1==null){
            return l2;
        }
        if(l2==null){
            return l1;
        }

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

要求去重的话，加上相等时候的判断

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        if(l1==null){
            return l2;
        }
        if(l2==null){
            return l1;
        }

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

        }

    }
}

迭代

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);

        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;

        return prehead.next;
    }
}

去重的话，加一个判断

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        ListNode dumpy =new ListNode(-1);
        ListNode pre=dumpy;
        while(l1!=null&&l2!=null){
            if(l1.val<l2.val){
                pre.next=l1;
                l1=l1.next;
            }else if(l1.val==l2.val){
                l1=l1.next;
                continue;
            }
            else{
                pre.next=l2;
                l2=l2.next;
            }

            pre=pre.next;
        }

        pre.next=l1==null?l2:l1;
        return dumpy.next;

    }
}

23. 合并K个升序链表

23. 合并K个升序链表

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        return merge(lists, 0, lists.length - 1);
    }

    public ListNode merge(ListNode[] lists, int l, int r) {
        if (l == r) {
            return lists[l];
        }
        if (l > r) {
            return null;
        }
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    public ListNode mergeTwoLists(ListNode a, ListNode b) {
        if (a == null || b == null) {
            return a != null ? a : b;
        }
        ListNode head = new ListNode(0);
        ListNode tail = head, aPtr = a, bPtr = b;
        while (aPtr != null && bPtr != null) {
            if (aPtr.val < bPtr.val) {
                tail.next = aPtr;
                aPtr = aPtr.next;
            } else {
                tail.next = bPtr;
                bPtr = bPtr.next;
            }
            tail = tail.next;
        }
        tail.next = (aPtr != null ? aPtr : bPtr);
        return head.next;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/he-bing-kge-pai-xu-lian-biao-by-leetcode-solutio-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

143. 重排链表

143. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

 L0 → L1 → … → Ln-1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

方法一：线性表
因为链表不支持下标访问，所以我们无法随机访问链表中任意位置的元素。

因此比较容易想到的一个方法是，我们利用线性表存储该链表，然后利用线性表可以下标访问的特点，直接按顺序访问指定元素，重建该链表即可。

class Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        List<ListNode> list = new ArrayList<ListNode>();
        ListNode node = head;
        while (node != null) {
            list.add(node);
            node = node.next;
        }
        int i = 0, j = list.size() - 1;
        while (i < j) {
            list.get(i).next = list.get(j);
            i++;
            if (i == j) {
                break;
            }
            list.get(j).next = list.get(i);
            j--;
        }
        list.get(i).next = null;
    }
}

方法二：寻找链表中点 + 链表逆序 + 合并链表

class Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        ListNode mid = middleNode(head);
        ListNode l1 = head;
        ListNode l2 = mid.next;
        mid.next = null;
        l2 = reverseList(l2);
        mergeList(l1, l2);
    }

    public ListNode middleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }

    public void mergeList(ListNode l1, ListNode l2) {
        ListNode l1_tmp;
        ListNode l2_tmp;
        while (l1 != null && l2 != null) {
            l1_tmp = l1.next;
            l2_tmp = l2.next;

            l1.next = l2;
            l1 = l1_tmp;

            l2.next = l1;
            l2 = l2_tmp;
        }
    }
}

141. 环形链表

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null||head.next==null){
            return false;
        }
        ListNode slow=head;
        ListNode fast=head.next;

        while(slow!=fast){
            slow=slow.next;
            if(fast!=null && fast.next!=null){
                fast=fast.next.next;
            }else{
                return false;
            }
        }
        return true;
        
    }
}

142. 环形链表 II

142. 环形链表 II

public class Solution {
    public ListNode detectCycle(ListNode head) {
          if(head==null||head.next==null){
            return null;
        }
        ListNode slow=head;
        ListNode fast=head;

        while(true){
            if(fast==null||fast.next==null){
                return null;
            }
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                break;
            }
        }
        ListNode res=head;
        while(res!=slow){
            slow=slow.next;
            res=res.next;
        }
        return res;
    }
}

链表反转从尾部开始

给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一组的不需要逆序。（不能使用队列或者栈作为辅助）

例如：链表:1->2->3->4->5->6->7->8->null, K = 3。那么 6->7->8，3->4->5，1->2各位一组。调整后：1->2->5->4->3->8->7->6->null。其中 1，2不调整，因为不够一组。

只需要先把单链表进行一次逆序，逆序之后就能转化为从头部开始组起了，然后按照上面的解法，处理完之后，把结果再次逆序即搞定。两次逆序相当于没逆序。

zdfunk
关注
专栏目录
链表经典算法题
Frank的博客
10-03 1806
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
数据结构——常见链表算法题
secretboys的博客
08-18 815
本文介绍常见的有关链表的算法题，值得一提的是，该代码无需在力扣上，可在本地运行成功。1.反转链表2.移除链表中的重复节点3.查找链表中的中间节点4.找到链表中的倒数第k个节点5.合并两个升序链表，并同样按照升序排列6.判断是否为环形链表7.查找两链表的交点，相交链表8.判断是否为回文链表（空链表和单节点链表也算）......
链表类算法题
qq_33690342的博客
02-19 663
1、反转链表leetcode 206： // ListNode Definition for singly-linked list. type ListNode struct { Val int Next *ListNode } func reverseList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } var prev *Li
链表相关算法题总结
weixin_43691723的博客
06-24 720
链表的问题比较常见，这种问题一般比较考验代码能力，这篇文章，总结了几道常见的链表题，思路不难，难的是代码。
链表 http://hi.baidu.com/silverxinger/item/3adfff97fcff3245f14215a6
coding for life
12-05 1135
数据结构-链表-奇思妙想 基本函数 1，构造节点：  //定义节点类型 struct Node { int value; Node*next; };   2，分配节点 //之所以要分配节点原因是需要在分配函数中进行初始化，并且也利于判断是否分配成功。 Node* applyNode();   3，在头部增加节点 //增加节点在头部（无头结点）,返回值的原因是由于传入并
链表相关算法题
shuaishuai5213的博客
01-02 113
文章目录一.反转链表1.全部反转（1）递归解法（2）非递归2.反转前n个（1）递归解法(2)非递归 一.反转链表 节点类型： public class ListNode { int val; ListNode next; } 头插法建表： public class Initial { static ListNode initial(){ int[] test = {1,2,3,4,5,6,7,8,9}; ListNode head = null; ListNode l
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
数据结构 - 链表 - 面试中常见的链表算法题
从零开始
01-17 4222
数据结构 - 链表 - 面试中常见的链表算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍线性表中的常见的链表数据结构。包括 概念简介 链表节点的数据结构（Java） 常见的链表算法题（Java）。 概念简介 如果对链表概念已经基本掌握，可以跳过该部
算法题：链表
qq_43721730的博客
12-29 355
算法题：链表 1.反转链表 描述 给定一个单链表的头结点pHead，长度为n，反转该链表后，返回新链表的表头。 数据范围： n\leq1000n≤1000 要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(N
和链表有关的算法题（C++）
tinyway的专栏
02-19 779
链表操作在面试中经常出现，这一方面考察了对指针的使用，以下整理了一些关于链表的面试题以及注意事项。 首先对单链表进行定义。 struct ListNode{ int val; ListNode *next; }; 问题1：输入一个单向链表，输出该链表中倒数第k个结点 先第一个指针向前走k，然后第二个指针此时和第一个指针一起走即可。 情况：pHead=NULL、链表小于
两个链表相交的一系列问题
OY_palada
07-26 428
程序员代码面试指南（左程云）读书笔记  第二章 两个链表相交的一系列问题   在本题中单链表可能有环，也可能没有环。给定连个单链表的头节点，head1和head2,这连个链表可能相交，也可能不相交。 请实现一个函数，如果两个链表相交，请返回相交的第一个节点，如果不相交，返回null; 要求：      如果链表1的长度为N,链表2的长的为W,时间复杂度问O（N+W）,额外空间复
几道链表相关的算法题
qq_31473465的博客
06-27 203
前置条件： public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } 一、给定一个链表，删除链表的倒数第n个节点，并且返回链表的头结点。 /** * 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 * &lt...
链表的算法题
最新发布
flyingcloud6的博客
01-19 1451
不用太在乎空间复杂度，一切为了时间复杂度。时间复杂度依然放在第一位，但一定要找到空间最省的办法。
链表 算法题
u012124634的博客
08-30 249
两个单向链表，找出它们的第一个公共结点。 http://blog.csdn.net/wcyoot/article/details/6426436 判断链表是否有环以及环入口
链表算法题解析：反转、查找与操作
"这篇文档详细介绍了与数据结构相关的面试题，特别是关于单链表的各种操作，包括反转链表、寻找特定位置的元素、合并链表、处理环形链表、链表排序以及删除重复元素等。它提供了一个C#实现的单链表类，并给出了若干...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值