链表题总结

已于 2024-09-05 14:37:37 修改
阅读量377 收藏 7
点赞数 3
分类专栏： 算法 文章标签： 链表 数据结构
于 2024-09-02 21:03:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Littleflowers/article/details/141824741
版权

链表题总结

hot100

相交链表

题目链接：
160.相交链表
代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA, p2 = headB;

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

反转链表

题目链接：
206.反转链表
代码：


class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode tmp;
        ListNode pre = null;
        ListNode curr = head;

        while(curr != null){
            tmp = curr.next;
            curr.next = pre;

            pre = curr;
            curr = tmp;
        }
        return pre;

    }
}

反转链表2

题目链接：
92.反转链表2
代码：


class Solution {
    public void reverse (ListNode head) {
        ListNode pre = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = pre;
            pre = curr;
            curr = next;
        }
    }
    public ListNode reverseBetween(ListNode head, int left, int right) {
        ListNode dummy = new ListNode(-1,head);
        ListNode pre = dummy;
        for (int i = 0; i < left - 1; i ++) {
            pre = pre.next;
        }
        ListNode rightNode = pre;
        for (int i = 0; i < right - left + 1; i ++) {
            rightNode = rightNode.next;
        }

        ListNode leftNode = pre.next;
        ListNode curr = rightNode.next;

        pre.next = null;
        rightNode.next = null;

        reverse(leftNode);
        pre.next = rightNode;
        leftNode.next = curr;
        return dummy.next;
    }
}

回文链表

题目链接：
234.回文链表
代码：


class Solution {
    public 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;
    }
    public ListNode cut(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 boolean isPalindrome(ListNode head) {
        if (head == null) return true;
        ListNode mid = cut(head);
        ListNode mids = reverse(mid.next);
        boolean result = true;
        ListNode l1 = head, l2 = mids;
        while (result && l2 != null) {
            if (l1.val != l2.val) {
                result = false;
            }
            l1 = l1.next;
            l2 = l2.next;
        }
        return result;
    }
}

环形链表

题目链接：
141.环形链表
代码：


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

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

            if (slow == fast) {
                return true;
            }
        }

        return false;
        
    }
}

环形链表2

题目链接：
142.环形链表2
代码：


public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head, slow = head;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;

            if (slow == fast){
                ListNode p1 = fast;
                ListNode p2 = head;
                while(p1 != p2){
                    p1 = p1.next;
                    p2 = p2.next;
                }
                return p1;
            }
        }
        return null;
        
    }
}

合并两个有序链表

题目链接：
21.合并两个有序链表
代码：


public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (list1 == null && list2 == null) return null;
        if (list1 == null) return list2;
        if (list2 == null) return list1;

        ListNode l;
        if (list2.val <= list1.val)
        {
            l = list2;
            list2 = list2.next;
        }else
        {
            l = list1;
            list1 = list1.next;
        }
        ListNode tmp = l;

        while(list1 != null && list2 != null)
        {
            if (list2.val <= list1.val)
            {
                tmp.next = list2;
                list2 = list2.next;
            }else
            {
                tmp.next = list1;
                list1 = list1.next;
            }
            tmp = tmp.next;
        }

        tmp.next = (list1 == null) ? list2:list1;
        return l;
        
    }
}

两数相加

题目链接：
2.两数相加
代码：


public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;
        int cary = 0;
        while (l1!= null || l2 != null) {
            int x = (l1 == null) ? 0 : l1.val;
            int y = (l2 == null) ? 0 : l2.val;
            int sum = x + y + cary;
            ListNode node = new ListNode(sum % 10);
            cary = sum / 10;
            curr.next = node;
            curr = curr.next;

            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }
        if (cary != 0) {
            ListNode node = new ListNode(cary);
            curr.next = node;
        }
        return dummy.next;
    }
}

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

题目链接：
19.删除链表的倒数第N个结点
代码：


public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode dummy = new ListNode(-1,head);
        ListNode first = dummy;
        ListNode second = dummy;
        for (int i = 0; i <= n; i ++){
            first = first.next;
        }
        while (first != null){
            first = first.next;
            second = second.next;
        }
        second.next = second.next.next;
        return dummy.next;
    }
}

两两交换链表中的节点

题目链接：
24.两两交换链表中的节点
代码：


public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode dummy = new ListNode(-1,head);
        ListNode curr = dummy;
        ListNode tmp;
        ListNode first;
        ListNode second;

        while (curr.next != null && curr.next.next != null){
            tmp = curr.next.next.next;
            first = curr.next;
            second = curr.next.next;
            curr.next = second;
            second.next = first;
            first.next = tmp;
            curr = first;
        }
        return dummy.next;
    }
}

K 个一组翻转链表

题目链接：
25.K 个一组翻转链表
代码：


public class Solution {
    public 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;
    }
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0,head);
        ListNode pre = dummy, end = dummy;
        while (end != null) {
            for (int i = 0; i < k && end!= null; i ++) {
                end = end.next;
            }
            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;
        }
        return dummy.next;

    }
}

随机链表的复制

题目链接：
138.随机链表的复制
代码：


/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    Map<Node,Node> map = new HashMap<>();
    public Node copyRandomList(Node head) {
        if (head == null) return null;
        if (! map.containsKey(head))
        {
            Node node = new Node(head.val);
            map.put(head,node);
            node.next = copyRandomList(head.next);
            node.random = copyRandomList(head.random);
        }
        return map.get(head);
    }
}

排序链表

题目链接：
148.排序链表
代码：

class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next!=null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        fast = slow.next;
        slow.next = null;
        ListNode left = sortList(head);
        ListNode right = sortList(fast);

        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;

        while (left != null && right != null) {
            if (left.val <= right.val) {
                curr.next = left;
                left = left.next;
            }else{
                curr.next = right;
                right = right.next;
            }
            curr = curr.next;
        }
        curr.next = left != null ? left:right;

        return dummy.next;

    }
}

合并 K 个升序链表

题目链接：
23.合并 K 个升序链表
代码：

class Solution {
    public ListNode merge (ListNode head1, ListNode head2){
        ListNode dummy = new ListNode(0);
        ListNode tmp = dummy, tmp1 = head1, tmp2 = head2;

        while (tmp1 != null && tmp2 != null){
            if (tmp1.val <= tmp2.val){
                tmp.next = tmp1;
                tmp1 = tmp1.next;
            }else{
                tmp.next = tmp2;
                tmp2 = tmp2.next;
            }
            tmp = tmp.next;
        }
        if (tmp1 != null) tmp.next = tmp1;
        if (tmp2 != null) tmp.next = tmp2;
        return dummy.next;
    }
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode res = null;
        for (int i = 0; i < lists.length; i ++){
            res = merge(res,lists[i]);
        }
        return res;

    }
}

LRU缓存

题目链接：
146.LRU缓存
代码：

class LRUCache {
    class DLink{
        int key;
        int value;
        DLink pre, next;
        DLink() {}
        DLink(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
    DLink head, tail;
    int size;
    int capacity;
    Map<Integer, DLink> map = new HashMap<>();

    public LRUCache(int capacity) {
        head = new DLink();
        tail = new DLink();
        head.next = tail;
        tail.pre = head;
        this.size = 0;
        this.capacity = capacity;

    }
    
    public int get(int key) {
        DLink node = map.get(key);
        if (node == null) {
            return -1;
        }
        moveTohead(node);
        return node.value;
        
    }
    
    public void put(int key, int value) {
        DLink node = map.get(key);
        if (node == null) {
            DLink n = new DLink(key,value);
            map.put(key, n);
            addToHead(n);
            size ++;
            if (size > capacity) {
                DLink deleNode = removeTail();
                map.remove(deleNode.key);
                size --;
            }
        }else {
            node.value = value;
            moveTohead(node);
        }

    }

    public void addToHead(DLink node) {
        node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
        // DLink next = head.next;
        // head.next = node;
        // node.pre = head;
        // node.next = next;
        // next.pre = node;
    }
    public void removeNode(DLink node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
    public DLink removeTail() {
        DLink node = tail.pre;
        removeNode(node);
        return node;
    }
    public void moveTohead(DLink node) {
        removeNode(node);
        addToHead(node);
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

重排链表

题目链接：
143.重排链表
代码：

class Solution {
    public 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;
    }
    public ListNode middleNode(ListNode head) {
        ListNode fast = head, slow = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    public void mergeList(ListNode l1, ListNode l2) {
        ListNode l1_tmp, 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;
        }
    }
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        ListNode mid = middleNode(head);
        ListNode l1 = head;
        ListNode l2 = mid.next;
        mid.next = null;
        l2 = reverse(l2);
        mergeList(l1, l2);
    }
}
小花不写代码
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表面试题总结
10-22
根据提供的文件信息，这里将对链表相关的面试题目进行总结，并深入探讨其中涉及的数据结构与算法知识点。 ### 链表基础知识回顾 在讨论具体的面试题之前，我们首先需要了解链表的基本概念及其操作方法。链表是一种...
python算法题 链表反转详解
09-19
### Python算法题：链表反转详解 在计算机科学与编程领域中，链表是一种常见的数据结构，被广泛应用于各种场景之中。链表反转是链表操作中最基础且重要的操作之一，它不仅能够帮助理解链表的基本操作原理，还能够在...
面试常见基础算法题总结
04-29
面试中的算法题是每个IT求职者都需要准备的重要环节，涵盖了数据结构、算法设计与分析等多个领域。以下是对一些常见算法题目的详细解析： 1. **红黑树**：红黑树是一种自平衡二叉查找树，它保持了二叉搜索树的特性...
链表面试题目总结 全
09-05
在计算机科学领域，链表是一种基本且非常重要的数据结构，它是面试中的常见考察点。链表通常由节点组成，每个节点包含数据部分和指向下一个节点的指针，最后一个节点指向null。链表分为单链表、双链表、循环链表等...
面试题总结：数组和链表的区别 数组和链表.pdf
04-18
数组和链表的区别 在计算机科学中，数组和链表是两种基本的数据结构，它们都广泛应用于软件开发和算法设计中。然而，数组和链表有着根本的区别，这些区别决定了它们在不同的场景下的应用。 数组 数组是一种连续...
【数据结构】LinkedList ------ java实现
C384136844的博客
09-05 1103
知识框架图：LinkedList是一种常用的数据结构。底层是一个双向链表。每个节点包含数据以及指向前一个节点和后一个节点的引用。
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1083
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长
sjsjs11的博客
09-04 928
这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。
数据结构(6.4_6)——拓扑排序
m0_65240792的博客
09-04 328
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 800
详解了推有关的两个面试题：堆排序，TopK问题
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 435
AVL树
数据结构-栈、队列-详解
2401_86587256的博客
09-04 1170
数据结构初阶部分，栈和队列的详解
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 695
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
数据结构（红黑树）
qq_63126439的博客
09-08 224
红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构。1972年出现，当时被称之为平衡二叉B树。后来，1978年被修改为如今的"红黑树"它是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色每一个节点可以是红或者黑;红黑树不是高度平衡的，它的平衡是通过"红黑规则"进行实现的。
数据结构——线性表（顺序存储结构和单链表结构）
最新发布
weixin_74209413的博客
09-08 606
线性表（List）：由零个或多个数据元素组成的有限序列。（1）它是一个序列，也就是元素之间有个先来后到的；（2）若元素有多个，则第一个元素无前驱，最后一个无后继；（3）线性表是有限的；原子类型：不可以再分解的基本类型，例如整形、浮点型、字符型等结构类型：由若干个类型组合而成，是可以再分解的，例如整形数组是由若干个整形数据组成的。抽象数据类型抽象数据类型是指一个数学模型及定义在该模型上的一组操作；抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。
数据结构：二叉树
2301_80744520的博客
09-05 975
顺序存储指的是按照满二叉树的结点层次编号，依次存放二叉树中的数据元素。如下图所示可以看到二叉树的顺序存储非常浪费空间，如左图，二叉树第五个结点虽然没有存储元素，但是这个结点依然要被占据。右图的单支树就是一种更加极端的情况。
数据结构串的模式匹配算法--BF暴力匹配
2305_78057683的博客
09-03 382
数据结构串的模式匹配算法--BF暴力匹配
数据结构07
m0_52024881的博客
09-04 399
条件1.vector或者List的长度小于当前的lever值的时候才将结点的值入vector或者List，这就保证了始终保留的是最右结点。不妨对照题干上的例子对照进行单步脑海运行一下。其中C++和java语言中都有一个重要的if筛选条件，还有一个条件是2.先遍历右孩子再遍历左孩子；
数据结构——顺序表
m0_66847953的博客
09-08 451
顺序表是一种基本的数据结构，它通过连续的内存空间来存储数据元素，每个元素占据相同的存储空间，且在逻辑上相邻的元素在物理位置上同样相邻（存储结构）。
数组、链表、树代码题总结及反馈建议
对于数组、链表和树的代码题，我们首先需要理解题目要求，明确问题的解决思路和步骤。在编写代码时，我们要尽量避免出现错误，可先进行一些简单的测试和调试，确保代码的正确性。在编码过程中，注释的使用也是十分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值