力扣技巧-链表

已于 2022-09-29 16:38:46 修改
阅读量332 收藏
点赞数
文章标签： 链表 leetcode 数据结构
于 2022-09-27 01:54:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41282486/article/details/127055323
版权
本文探讨了链表相关的LeetCode题目，包括设计链表、反转链表、删除重复元素、合并链表等。文章介绍了三种核心策略：假头处理、新链表构建和双指针技术，并通过具体题目如删除链表倒数N个节点、环形链表等展示了这些方法的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

707. 设计链表
class MyLinkedList {

    private class ListNode {
        public int val;
        public ListNode next;
        public ListNode(int val) {
            this.val = val;
        }

        public ListNode() {

        }
    }

    private ListNode dummy = new ListNode();
    private int length = 0;
    private ListNode tail = dummy;

    public MyLinkedList() {

    }

    private ListNode getPreNode(int index) {

        ListNode front = dummy.next;
        ListNode back = dummy;
        for (int i = 0; i < index; i ++) {
            back = front;
            front = front.next;
        }

        return back;
    }
    
    public int get(int index) {

        if (index < 0 || index >= length) {
            return -1;
        }

        return getPreNode(index).next.val;
    }
    
    public void addAtHead(int val) {
        ListNode p = new ListNode(val);
        p.next = dummy.next;
        dummy.next = p;
        if (tail == dummy) {
            tail = p;
        }
        length ++;
    }
    
    public void addAtTail(int val) {
        ListNode p = new ListNode(val);
        tail.next = p;
        tail = p;
        length ++;
    }
    
    public void addAtIndex(int index, int val) {
        if (index > length) {
            return;
        } else if (index == length) {
            addAtTail(val);
            return;
        } else if (index <= 0) {
            addAtHead(val);
            return;
        }

        ListNode pre = getPreNode(index);
        ListNode p = new ListNode(val);
        p.next = pre.next;
        pre.next = p;
        length ++;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= length) {
            return;
        }

        ListNode pre = getPreNode(index);
        if (tail == pre.next) {
            tail = pre;
        }
        length --;
        pre.next = pre.next.next;
    }
}
206. 反转链表
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode temp = head;
        ListNode dummy = new ListNode();
    
        while (null != temp) {
            ListNode p = new ListNode(temp.val);
            p.next = dummy.next;
            dummy.next = p;
            temp = temp.next;
        }

        return dummy.next;
    }
}
203. 移除链表元素
class Solution {
    public ListNode removeElements(ListNode head, int val) {

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode back = dummy;
        ListNode front = dummy.next;

        while (null != front) {

            while (null != front && val == front.val) {
                front = front.next;
            }

            back.next = front;
            back = back.next;
            if (null != front) {
                front = front.next;
            }
        }

        return dummy.next;
    }
}
83. 删除排序链表中的重复元素
class Solution {
    public ListNode deleteDuplicates(ListNode head) {

        ListNode front = head;
        ListNode back = head;

        while (null != front) {

            while (null != front && back.val == front.val) {
                front = front.next;
            }

            back.next = front;
            back = front;
        }

        return head;
    }
}
82. 删除排序链表中的重复元素 II
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
       // 这里我们采用新生成2条件新链表的思路

        // ans 这个链表总是用来存放返回结果
        ListNode ans = new ListNode();
        ListNode ans_tail = ans;

        // tmp 这个链表中总是用来存放相同元素。
        // 如果发现要append一个不同的
        ListNode tmp = new ListNode();
        ListNode tmp_tail = tmp;
        ListNode p = head;

        while (p != null) {
            ListNode back = p.next;

            // 如果tmp链表为空，或者tmp链表中的元素和p.val
            // 相等 => 那么把p添加到tmp链表中
            if (tmp_tail == tmp || p.val == tmp_tail.val) {
                tmp_tail.next = p;
                tmp_tail = p;
            } else {
                // 如果发现和tmp链表中的元素不相等
                // 那么看一下tmp链表中的结点个数
                // 如果tmp链表中只有一个结点
                if (tmp_tail == tmp.next) {
                    // 那么这里把这个结点放到ans中
                    ans_tail.next = tmp.next;
                    ans_tail = ans_tail.next;
                }
                // 如果tmp链表中有多个结点，那么什么也不做

                // 无论tmp链表中是一个结点，还是有多个结点
                // 都要清空tmp链表

                tmp_tail = tmp;
                tmp.next = null;

                // 再把p结点安装到tmp上
                // 可以和前面的语句合并
                // 这里为了逻辑更清晰这么写。
                tmp_tail.next = p;
                tmp_tail = p;
            }

            p = back;
        }

        // 如果tmp链表中还有元素，并且只有一个
        if (tmp_tail == tmp.next) {
            ans_tail.next = tmp.next;
            ans_tail = ans_tail.next;
        }
        ans_tail.next = null;

        return ans.next;
    }
}
21. 合并两个有序链表
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        if (null == list1 && null == list2) {
            return null;
        }

        if (null == list1) {
            return list2;
        }

        if (null == list2) {
            return list1;
        }

        ListNode res = new ListNode(Integer.MIN_VALUE);
        ListNode tail = res;

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

        while (null != list1) {
            tail.next = new ListNode(list1.val);
            tail = tail.next;
            list1 = list1.next;
        }

        while (null != list2) {
            tail.next = new ListNode(list2.val);
            tail = tail.next;
            list2 = list2.next;
        }

        return res.next;
    }
}
23. 合并K个升序链表
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        final int n = (null == lists ? 0 : lists.length);
        Queue<ListNode> queue = new PriorityQueue<>((v1, v2) -> v1.val - v2.val);

        for (int i = 0; i < n; i ++) {
            ListNode node = lists[i];
            if (null != node) {
                queue.add(node);
            }
        }

        ListNode dummy = new ListNode();
        ListNode tail = dummy;

        while (!queue.isEmpty()) {

            ListNode curNode = queue.poll();
            tail.next = curNode;
            tail = tail.next;
            if (null != curNode.next) {
                queue.add(curNode.next);
            }
        }

        tail.next = null;

        return dummy.next;
    }
}
24. 两两交换链表中的节点
class Solution {
    public ListNode swapPairs(ListNode head) {

        if (null == head) {
            return head;
        }

        ListNode front = head.next;
        ListNode back = head;

        while (null != front) {

            int temp = back.val;
            back.val = front.val;
            front.val = temp;

            if (null == front.next) {
                front = null;
            } else {
                back = back.next.next;
                front = front.next.next;
            }
        }

        return head;
    }
}

双指针

1.间隔指针：前面的指针先走一步，然后后面的指针再一起走；前面的指针先走 k 步，后面的指针再一起走。
2。快慢指针：两个指针的速度一快一慢前进，比如一个每次走一步，一个每次走两步。

19. 删除链表的倒数第 N 个结点
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {

        ListNode dummy = new ListNode();
        dummy.next = head;

        int preWalkedSteps = 0;
        ListNode front = dummy;
        while (preWalkedSteps < n && null != front && null != front.next) {
            front = front.next;
            preWalkedSteps ++;
        }

        ListNode back = dummy;
        while (null != front && null != front.next) {
            back = back.next;
            front = front.next;
        }

        if (preWalkedSteps == n) {
            back.next = back.next.next;
        }

        return dummy.next;
    }
}
让指针指向链表最后一个结点的 while 语句的写法
while (null != front && null != front.next) {
	// your code
}
141. 环形链表
public class Solution {
    public boolean hasCycle(ListNode head) {

       ListNode front = head;
       ListNode back = head;

        while (null != front && null != front.next) {
            back = back.next;
            front = front.next.next;
            if (back == front) {
                return true;
            }
        }

        return false;
    }
}
142. 环形链表 II
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode front = dummy;
        ListNode back = dummy;
        boolean flag = false;

        while (null != front && null != front.next) {
            back = back.next;
            front = front.next.next;
            if (back == front) {
                flag = true;
                break;
            }
        }

        if (!flag) {
            return null;
        }

        back = dummy;
        while (back != front) {
            back = back.next;
            front = front.next;
        }

        return front;
    }
}

总结：
第一斧：假头。假头的作用主要是避免关于空链表的判断与讨论，假头还可以用来避免检查前驱结点为空的情况。

第二斧：新链表。新链表的引入是为了解决在旧链表中进行原地的交换、插入、删除，把复杂的操作变成在新链表中头部插入或者尾部添加。

第三斧：双指针。双指针主要是用于寻找链表中的特定结点，双指针的走法可以一次一步，可以有快有慢，出发点也可以有前有后。

148. 排序链表
class Solution {
    public ListNode sortList(ListNode head) {

        Queue<ListNode> queue = new PriorityQueue<>((v1, v2) -> (v1.val - v2.val));
        while (null != head) {
            queue.add(head);
            head = head.next;
        }

        ListNode dummy = new ListNode();
        ListNode tail = dummy;

        while (!queue.isEmpty()) {
            ListNode curNode = queue.poll();
            tail.next = curNode;
            tail = tail.next;
            tail.next = null;
        }

        return dummy.next;
    }
}
160. 相交链表
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

        ListNode tempA = headA;
        ListNode tempB = headB;
        boolean flagA = false;
        boolean flagB = false;

        while (tempA != tempB) {
            tempA = tempA.next;
            if (null == tempA) {
                if (flagA) {
                    return null;
                }
                flagA = true;
                tempA = headB;
            }

            tempB = tempB.next;
            if (null == tempB) {
                if (flagB) {
                    return null;
                }
                flagB = true;
                tempB = headA;
            }
        }

        return tempA;
    }
}
328. 奇偶链表
class Solution {
    public ListNode oddEvenList(ListNode head) {

        if (null == head) {
            return null;
        }

        ListNode odd = head;
        ListNode oddHead = head;
        ListNode even = head.next;
        ListNode evenHead = head.next;

        while (null != even && null != even.next) {
            odd.next = even.next;
            odd = odd.next;
            even.next = odd.next;
            even = even.next;
        }
        odd.next = evenHead;

        return head;
    }
}
234. 回文链表
class Solution {
    public boolean isPalindrome(ListNode head) {

        Stack<ListNode> stack = new Stack<>();
        ListNode curNode = head;
        while (null != curNode) {
            stack.add(curNode);
            curNode = curNode.next;
        }

        while (null != head) {
            if (head.val != stack.pop().val) {
                return false;
            }
            head = head.next;
        }

        return true;
    }
}
430. 扁平化多级双向链表
class Solution {
    public Node flatten(Node head) {
        Node curNode = head;
        while (null != curNode) {
            if (null == curNode.child) {
                curNode = curNode.next;
            } else {
                Node temp = curNode.next;
                Node curNext = flatten(curNode.child);
                curNode.child = null;
                curNode.next = curNext;
                curNext.prev = curNode;
                while (null != curNode.next) {
                    curNode = curNode.next;
                }
                if (null != temp) {
                    curNode.next = temp;
                    temp.prev = curNode;
                }
                
            }
        }

        return head;
    }
}
远腾飞
关注
力扣---删除链表的倒数第 N 个结点
m0_71536793的博客
04-05 622
力扣 链表
力扣--让字符串成为回文串的最少插入次数
wolfGuiDao的博客
09-02 1351
力扣–让字符串成为回文串的最少插入次数 文章目录力扣--让字符串成为回文串的最少插入次数一、题目描述二、分析三、代码 相关题目： 腾讯–构造回文：腾讯–构造回文 最长回文子串和回文链表：最长回文子串和回文链表 美团/力扣(647)–回文字串：美团/力扣(647)–回文字串 力扣- - 最短回文串（KMP算法）：力扣- - 最短回文串（KMP算法） 最长回文子序列：最长回文子序列 一、题目描述 二、分析 首先，要找最少的插入次数，那肯定得穷举喽，如果我们用暴力算法穷举出所有插入
力扣--链表（力扣）
qq_43205877的博客
08-08 397
Java
力扣-----链表
laugh哥的博客
09-15 1158
力扣专题：链表 链表是一种特殊的线性结构，由于不能像数组一样进行随机的访问，所以和链表相关的问题有他自身的穿针引线特点。
力扣——链表篇
xiaowanziddd的博客
04-01 761
力扣——链表篇 移除链表元素 203.给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 思路：借助一个虚拟的头结点，进行链表的遍历找到与目标数，将当前指针指向当前指针的下一个节点的下一个节点，就可以实现删除操作。 class Solution { public ListNode removeElements(ListNode head, int val) { if(head == null){
LeetCode（707）：设计链表 Design Linked List（Java）
NJU_ChopinXBP的博客
11-05 489
2019.11.5 #程序员笔试必备# LeetCode 从零单刷个人笔记整理（持续更新） github：https://github.com/ChopinXBP/LeetCode-Babel 数据结构题，应知应会。 传送门：设计链表 Design your implementation of the linked list. You can choose to use the singly ...
[力扣]链表
weixin_51699336的博客
04-17 161
概述 1.概念 不一定连续存储空间 以节点的方式存储 每个节点包含data,next 2.类型 单链表(data,next) 双链表(pre,data,next) 循环链表(尾节点next指向head) 3.存储方式 存储空间不连续 4.操作 删除节点 添加节点 5.总结 链表主要动笔画出链表间前后节点的关系 只有最后一题需要数学思想，其他就基本操作 移除链表元素[203] class Solution { public ListNode removeElements(Li
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
Leet Code 力扣 - - 最短最优雅python解法带解析汇总
Knife丶小刀博客
04-19 4660
Leet Code 刷题笔记 记录一下刷过的有意义和代表性的题 动态规划 Unique Paths 题目可以转换为排列组合问题，解是C(min(m,n), m+n)，从m+n个中选出m个下移或n个右移。 用DP做很快，以后算 C(a, b) 都可以用算这题的DP法代替 ...
力扣---两数相加
最新发布
m0_71536793的博客
03-20 280
链表 力扣
力扣刷题篇——链表篇
weixin_59796310的博客
05-22 964
力扣刷题篇——链表篇
力扣算法之链表
qq_43569680的博客
03-25 623
链表 基本概念 链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口节点称为链表的头结点也就是head。 链表类型 单链表（上述就是单链表）：每个节点只有一个指针域，节点只能指向节点的下一个节点 双链表（每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点），既可以向前查询也可以向后查询 循环链表（链表首尾相连）：用来解决约瑟夫环问题 约瑟夫环问题：
力扣环形链表
dayday学习的博客
01-28 495
力扣环形链表 要求 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 ...
力扣链表题
weixin_46640232的博客
11-20 246
1.构造链表 设计链表 public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } class MyLinkedList { int size; ListNode head; // sentinel node as pseudo-head public MyLinkedList() { size = 0; head = new ListNode(0); }
力扣-链表-（21/83/）
qq_42411214的博客
09-23 303
21：合并两个有序的单链表 * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2...
力扣（LeetCode）141. 环形链表
Pwnpanda的博客
05-14 385
给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 输出：true 解释...
力扣LeetCode-链表
weixin_56005963的博客
02-16 672
链表 一、链表节点定义 // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 定义一个节点 ListNode* head = new ListNode(5); 二、设置虚拟头结点 作用：设置虚拟头结点使对头结点的处理普遍化 ListNode* dummyH...
力扣 链表 简单题
lllmmm1的博客
05-11 366
面试题52. 两个链表的第一个公共节点 双指针法： 面试题24. 反转链表 (1) 好理解的双指针 pre在前，cur在后，两者同时移动； (2) 递归 (3) 妖魔化的双指针 head不动，通过cur的移动反转链表。 遇到的错误是： 循环判断条件开始写成 while(cur-) ...
力扣插入链表
xiangguang_fight的博客
11-20 242
对链表进行插入排序。 插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。 每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。 插入排序算法： 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。 重复直到所有输入数据插入完为止。 示例 1： 输入: 4->2->1->3 输出: 1->2-.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值