链表的经典算法题

于 2023-11-19 13:54:51 发布
阅读量132 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alaskan_Husky/article/details/134489769
版权

链表是常见的数据结构之一，有许多经典的算法问题涉及到链表。以下是一些常见的链表算法题目：

  1. 反转链表（Reverse Linked List）： 将链表反转，即将原链表的每个节点的指针方向反向。

  2. 判断链表是否有环（Linked List Cycle）： 判断链表中是否存在环，即链表是否形成了一个闭环。

  3. 合并两个有序链表（Merge Two Sorted Lists）： 将两个有序链表合并成一个有序链表。

  4. 删除链表中的重复元素（Remove Duplicates from Sorted List）： 删除有序链表中的重复元素，使每个元素只出现一次。

  5. 删除链表的倒数第N个节点（Remove Nth Node From End of List）： 删除链表中倒数第N个节点。

  6. 求链表的中间节点（Middle of the Linked List）： 找到链表的中间节点，如果有两个中间节点，返回第二个。

  7. 交换相邻的节点（Swap Nodes in Pairs）： 交换链表中相邻的节点，返回新的头节点。

  8. 回文链表（Palindrome Linked List）： 判断链表是否是回文结构，即链表从前往后和从后往前读是相同的。

  9. 环形链表的起始节点（Linked List Cycle II）： 找到环形链表的起始节点。

  10. 相交链表（Intersection of Two Linked Lists）： 找到两个链表相交的起始节点。

这些题目涵盖了链表的基本操作、逆序、合并、查找中间节点、删除操作等常见场景。解决这些问题有助于熟练掌握链表的各种操作和应用。

反转链表(从前往后遍历，也可以从后往前递归)

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class ReverseLinkedList {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode current = head;

        while (current != null) {
            ListNode nextTemp = current.next;
            current.next = prev;
            prev = current;
            current = nextTemp;
        }

        return prev;
    }

    // 示例
    public static void main(String[] args) {
        // 创建链表: 1 -> 2 -> 3 -> 4 -> 5
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);

        ReverseLinkedList solution = new ReverseLinkedList();
        ListNode reversedHead = solution.reverseList(head);

        // 打印反转后的链表
        while (reversedHead != null) {
            System.out.print(reversedHead.val + " ");
            reversedHead = reversedHead.next;
        }
    }
}

判断链表是否有环（双指针）

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

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

        ListNode slow = head;
        ListNode fast = head.next;

        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false; // 若存在环，快指针不可能为null
            }

            slow = slow.next;
            fast = fast.next.next;
        }

        return true;
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个有环的链表: 1 -> 2 -> 3 -> 4 -> 5 -> 2
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);
        head.next.next.next.next.next = head.next; // 5指向2，形成环

        LinkedListCycle solution = new LinkedListCycle();
        boolean hasCycle = solution.hasCycle(head);

        System.out.println("链表是否有环: " + hasCycle);
    }
}

合并两个有序链表 

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class MergeTwoSortedLists {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;

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

        if (l1 != null) {
            current.next = l1;
        }

        if (l2 != null) {
            current.next = l2;
        }

        return dummy.next;
    }

    // 示例
    public static void main(String[] args) {
        // 创建两个有序链表: l1 = 1->2->4, l2 = 1->3->4
        ListNode l1 = new ListNode(1);
        l1.next = new ListNode(2);
        l1.next.next = new ListNode(4);

        ListNode l2 = new ListNode(1);
        l2.next = new ListNode(3);
        l2.next.next = new ListNode(4);

        MergeTwoSortedLists solution = new MergeTwoSortedLists();
        ListNode mergedList = solution.mergeTwoLists(l1, l2);

        // 打印合并后的链表
        while (mergedList != null) {
            System.out.print(mergedList.val + " ");
            mergedList = mergedList.next;
        }
    }
}

删除链表中的重复元素

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class RemoveDuplicatesFromSortedList {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode current = head;

        while (current != null && current.next != null) {
            if (current.val == current.next.val) {
                current.next = current.next.next; // 删除重复节点
            } else {
                current = current.next; // 指针移动到下一个节点
            }
        }

        return head;
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个有序链表: 1 -> 1 -> 2 -> 3 -> 3
        ListNode head = new ListNode(1);
        head.next = new ListNode(1);
        head.next.next = new ListNode(2);
        head.next.next.next = new ListNode(3);
        head.next.next.next.next = new ListNode(3);

        RemoveDuplicatesFromSortedList solution = new RemoveDuplicatesFromSortedList();
        ListNode result = solution.deleteDuplicates(head);

        // 打印删除重复元素后的链表
        while (result != null) {
            System.out.print(result.val + " ");
            result = result.next;
        }
    }
}

删除链表的倒数第N个节点(双指针)

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class RemoveNthNodeFromEnd {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode slow = dummy;
        ListNode fast = dummy;

        // 将快指针先移动N步
        for (int i = 0; i <= n; i++) {
            fast = fast.next;
        }

        // 同时移动慢指针和快指针
        while (fast != null) {
            slow = slow.next;
            fast = fast.next;
        }

        // 删除倒数第N个节点
        slow.next = slow.next.next;

        return dummy.next;
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个链表: 1 -> 2 -> 3 -> 4 -> 5
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);

        RemoveNthNodeFromEnd solution = new RemoveNthNodeFromEnd();
        int n = 2;
        ListNode result = solution.removeNthFromEnd(head, n);

        // 打印删除倒数第N个节点后的链表
        while (result != null) {
            System.out.print(result.val + " ");
            result = result.next;
        }
    }
}

求链表的中间节点(快慢指针)

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class MiddleOfTheLinkedList {
    public ListNode middleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        return slow;
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个链表: 1 -> 2 -> 3 -> 4 -> 5
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);

        MiddleOfTheLinkedList solution = new MiddleOfTheLinkedList();
        ListNode result = solution.middleNode(head);

        // 打印链表的中间节点
        System.out.println("链表的中间节点值为: " + result.val);
    }
}

交换相邻的节点 

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class SwapNodesInPairs {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode current = dummy;

        while (current.next != null && current.next.next != null) {
            ListNode first = current.next;
            ListNode second = current.next.next;

            // 交换相邻的节点
            first.next = second.next;
            second.next = first;
            current.next = second;

            current = current.next.next;
        }

        return dummy.next;
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个链表: 1 -> 2 -> 3 -> 4 -> 5
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);

        SwapNodesInPairs solution = new SwapNodesInPairs();
        ListNode result = solution.swapPairs(head);

        // 打印交换相邻节点后的链表
        while (result != null) {
            System.out.print(result.val + " ");
            result = result.next;
        }
    }
}

 回文链表

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class PalindromeLinkedList {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) {
            return true; // 空链表或只有一个节点的链表是回文链表
        }

        // 快慢指针找到链表中点
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        // 反转后半部分链表
        ListNode reversedSecondHalf = reverseList(slow);

        // 比较前半部分和反转后的后半部分
        while (reversedSecondHalf != null) {
            if (head.val != reversedSecondHalf.val) {
                return false;
            }
            head = head.next;
            reversedSecondHalf = reversedSecondHalf.next;
        }

        return true;
    }

    private ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode current = head;

        while (current != null) {
            ListNode nextTemp = current.next;
            current.next = prev;
            prev = current;
            current = nextTemp;
        }

        return prev;
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个回文链表: 1 -> 2 -> 3 -> 2 -> 1
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(2);
        head.next.next.next.next = new ListNode(1);

        PalindromeLinkedList solution = new PalindromeLinkedList();
        boolean isPalindrome = solution.isPalindrome(head);

        System.out.println("链表是否是回文链表: " + isPalindrome);
    }
}

环形链表的起始节点 

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class LinkedListCycleII {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;

        // 判断是否有环
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;

            if (slow == fast) {
                // 相遇点
                break;
            }
        }

        // 如果没有环，返回null
        if (fast == null || fast.next == null) {
            return null;
        }

        // 将一个指针移到链表头
        slow = head;

        // 两个指针同时前进，直到相遇点
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }

        return slow; // 返回相遇点，即环的起始节点
    }

    // 示例
    public static void main(String[] args) {
        // 创建一个有环的链表: 1 -> 2 -> 3 -> 4 -> 5 -> 2
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);
        head.next.next.next.next.next = head.next; // 5指向2，形成环

        LinkedListCycleII solution = new LinkedListCycleII();
        ListNode startOfCycle = solution.detectCycle(head);

        // 打印环的起始节点值
        System.out.println("环的起始节点值为: " + startOfCycle.val);
    }
}

相交链表

class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class IntersectionOfTwoLinkedLists {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = getLength(headA);
        int lenB = getLength(headB);

        // 计算链表长度差
        int diff = Math.abs(lenA - lenB);

        // 将长链表的指针移动到与短链表相同长度的位置
        if (lenA > lenB) {
            headA = movePointer(headA, diff);
        } else {
            headB = movePointer(headB, diff);
        }

        // 同时遍历两个链表，找到相交节点
        while (headA != null && headB != null) {
            if (headA == headB) {
                return headA;
            }
            headA = headA.next;
            headB = headB.next;
        }

        return null;
    }

    private int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            length++;
            head = head.next;
        }
        return length;
    }

    private ListNode movePointer(ListNode head, int steps) {
        for (int i = 0; i < steps; i++) {
            head = head.next;
        }
        return head;
    }

    // 示例
    public static void main(String[] args) {
        // 创建两个相交的链表
        // List A: 1 -> 2 -> 3 -> 6 -> 7
        // List B: 4 -> 5 -> 6 -> 7
        ListNode headA = new ListNode(1);
        headA.next = new ListNode(2);
        headA.next.next = new ListNode(3);
        headA.next.next.next = new ListNode(6);
        headA.next.next.next.next = new ListNode(7);

        ListNode headB = new ListNode(4);
        headB.next = new ListNode(5);
        headB.next.next = headA.next.next.next; // 相交于节点 6

        IntersectionOfTwoLinkedLists solution = new IntersectionOfTwoLinkedLists();
        ListNode intersectionNode = solution.getIntersectionNode(headA, headB);

        // 打印相交节点的值
        System.out.println("两个链表的相交节点值为: " + intersectionNode.val);
    }
}

 

阿狸轰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表经典算法题
Frank的博客
10-03 1681
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
【数据结构与算法-链表经典例题汇总】
是小武呀
03-01 1662
【数据结构与算法-链表经典例题汇总】典例1、链表逆序-a（easy）典例1、链表逆序-b（medium）典例2、求两个链表的交点-（easy）典例3、链表求环 - （medium）典例4、链表划分- (medium)典例5、复杂链表的深度拷贝 - (hard)典例6、排序链表的合并a-两个（easy）典例6、排序链表的合并b-多个（hard） 典例1、链表逆序-a（easy） 题目描述： 思路：依次遍历链表的节点，每遍历一个节点就逆置一个节点 。 LeetCode提交OJ测试链接: OJ
Leetcode题解——数据结构之链表
dieshi8689的博客
06-12 674
1. 找出两个链表的交点 2. 链表反转 3. 归并两个有序的链表 4. 从有序链表中删除重复节点 5. 删除链表的倒数第 n 个节点 6. 交换链表中的相邻结点 7. 链表求和 8. 回文链表 9. 分隔链表 10. 链表元素按奇偶聚集 链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。 1. 找出两个链表的交点 1...
【数据结构】链表经典算法题集锦
林慢慢的博客
09-12 9571
前言：本章将分享十一道来自LeetCode/牛客网中的经典链表算法题来介绍数据结构中链表在算法题中的应用。 文章目录1.删除链表元素思路分析：题解：2.反转链表思路分析：题解：3.链表中间结点思路分析（快慢指针法）：题解：4.链表中倒数第K个结点思路分析（快慢指针法）：题解：5.合并两个有序链表思路分析：题解：6.链表分割思路分析：题解：7.链表的回文结构(第2题和第3题的综合)思路分析：题解：8.相交链表思路分析：题解：9.环形链表I思路分析：题解：10.环形链表II思路分析：题解：11.复制带随机指针
链表算法题
printf_hao的博客
08-01 129
1.链表反转 leetcode链接 利用栈先入先出 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* reverseList(ListNode* head)
链表类算法题
qq_33690342的博客
02-19 595
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
链表 http://hi.baidu.com/silverxinger/item/3adfff97fcff3245f14215a6
coding for life
12-05 1094
数据结构-链表-奇思妙想 基本函数 1，构造节点：  //定义节点类型 struct Node { int value; Node*next; };   2，分配节点 //之所以要分配节点原因是需要在分配函数中进行初始化，并且也利于判断是否分配成功。 Node* applyNode();   3，在头部增加节点 //增加节点在头部（无头结点）,返回值的原因是由于传入并
链表经典编程题.zip
04-19
通过深入理解和熟练掌握这些链表编程题，不仅可以提升对链表的理解，还能锻炼解决问题的能力，为后续学习更复杂的数据结构和算法打下坚实基础。无论是初学者还是有一定经验的程序员，都可以从这些经典题目中获益。
python算法题 链表反转详解
09-19
主要介绍了python算法题 链表反转,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java经典算法练习题
11-02
本压缩包包含了三个文档，分别是“JAVA经典算法40题.doc”、“最新JAVA编程题全集_50题及答案.doc”和“50道JAVA基础编程练习题.doc”，这些资源为初学者提供了大量的实践机会，有助于深入理解和运用Java。...
经典算法题大全
04-22
【标题】"经典算法题大全"揭示了这个压缩包的核心内容——它是一个包含大量算法问题的集合，专门针对像蓝桥杯这样的编程竞赛。蓝桥杯是中国一项知名的计算机编程比赛，旨在提升参赛者的算法设计与实现能力。这些题目...
链表的算法题
flyingcloud6的博客
01-19 1426
不用太在乎空间复杂度，一切为了时间复杂度。时间复杂度依然放在第一位，但一定要找到空间最省的办法。
链表常考算法
DOS5GW的专栏
04-06 1413
http://www.aowe.net/n6296c6.aspx http://blog.sina.com.cn/s/blog_622119290100g2xo.html 比较全: 链表题：一个链表的结点结构struct Node{int data ;Node *next ;};typedef struct Node Node ; (1)已知链
【常用算法思路分析系列】链表相关高频题集
开心阳
05-24 7346
本文是【常用算法思路分析系列】的第四篇，总结链表相关的高频题目和解题思路。本文分析如下几个问题：1、环形链表的差值问题；2、只能访问单个结点的删除问题；3、链表的分化；4、打印两个链表的公共部分；5、把链表的每k个结点逆序；6、删除链表中指定结点；7、判断链表是否为回文结构；8、复杂链表的复制；9、判断链表是否有环；10、判断两个无环链表是否相交；11、判断两个有环链表是否相交；12、判断两个链表
链表经典算法题总结(二)
zag666的博客
03-22 673
83. 删除排序链表中的重复元素 234. 回文链表 141. 环形链表 142. 环形链表 II
链表中倒数第K个节点
weixin_A13253323604
09-17 188
#include <stdio.h> #include <stdlib.h> /*常规做法：遍历两次，第一次求链表长度，第二次求对应节点 简化做法（只走一次）：用两个指针，一个先走，另一个在他之后，k个节点，开始进*/ typedef struct List{ int data; struct List *next; }List; /*创建并插入链表*/ void CreatList(List *head,int data) { List *Te
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6604
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
【数据结构】图文详解11道力扣链表OJ题
学了就忘是正常现象
08-15 946
这是碳基生物能想到的思路？
【数据结构与算法】8道链表面试真题超详剖析，带你领略算法思想【附思路、动图、源码】
m0_67401761的博客
06-18 202
?? 前情提要??本章节是的的相关讲解~以下的内容一定会让你对相关知识的题目,有一个颠覆性的认识哦！！！以下内容以的方式实现以下内容干货满满，跟上步伐吧~作者介绍：大家可以跟着本文的题目讲解进行相关知识的复习&加深也欢迎大家上手测试一波????题目传送门：Leetcode：203. 移除链表元素给你一个链表的头节点 和一个整数 ，请你删除链表中所有满足 的节点，并返回新的头节点 示例 2：输入：head = [], val = 1 输出：[]示例 3：输入：head = [7,7,7,7], val
算法面试题总结_嵌入式-常用知识&面试题库_大厂面试真题.doc
最新发布
08-07
算法面试题总结_嵌入式-常用知识&面试题库_大厂面试真题.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值