LeetCode刷题之链表基础

最新推荐文章于 2023-02-04 04:38:59 发布
最新推荐文章于 2023-02-04 04:38:59 发布
阅读量161 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lentolove/article/details/120048113
版权

在这里插入图片描述

请添加图片描述

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

请添加图片描述

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode slow = dummy,fast = dummy.next;
        while(n  > 0){
            fast = fast.next;
            n--;
        }
        while(fast != null){
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}

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) {
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while(l1 != null && l2 != null){
            if(l1.val < l2.val){
                cur.next = l1;
                l1 = l1.next;
            }else{
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        cur.next = l1 == null ? l2 : l1;
        return dummy.next;
    }
}

23. 合并K个升序链表

请添加图片描述
方法一：借助优先队列实现

class Solution {

    //1.方法一：借助优先队列
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists.length < 1) return null;
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        PriorityQueue<ListNode> queue = new PriorityQueue<>((o1,o2) ->{
            return o1.val - o2.val;
        });
        //将每个链表的头节点加入到优先队列中
        for(ListNode node : lists){
            if(node == null) continue;
            queue.add(node);
        }
        //开始从优先队列中取出元素
        while(!queue.isEmpty()){
            //取出链表中头节点最小的节点
            ListNode minHead = queue.poll();
            cur.next = minHead;
            //接着将 minHead 的下一个节点继续添加到 queue中
            if(minHead.next != null) queue.add(minHead.next);
            cur = cur.next; 
        }
        return dummy.next;
    }
}

方法二：分治法，采用合并两个有序链表的思路：

class Solution {

    //方法二：分治法
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists == null || lists.length == 0) return null;
        return mergeKLists(lists,0, lists.length - 1);
    }

    public ListNode mergeKLists(ListNode[] lists,int l, int r){
        if(l >= r){
            return lists[l];
        }
        int mid = (l + r) / 2;
        ListNode l1 = mergeKLists(lists,l,mid);
        ListNode l2 = mergeKLists(lists,mid + 1,r);
        return mergeTwoLists(l1,l2);
    }

    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;
        }
    }
}

24. 两两交换链表中的节点

请添加图片描述

递归代码：

class Solution {
    //1.递归    
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }
}

迭代版本：

class Solution {
    //2.迭代
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1);
        ListNode cur = head,pre = dummy;
        dummy.next = cur;
        while(cur != null && cur.next != null){
            ListNode next = cur.next;
            pre.next = next;
            cur.next = next.next;
            next.next = cur;
            pre = cur;
            cur = cur.next;
        }
        return dummy.next;
    }
}

25. K 个一组翻转链表

请添加图片描述

方法一：通过Stack来做链表翻转

class Solution {
    /**
        * 方法二：⽤用栈 每k个节点压⼊入栈中 弹出的就是翻转的链表
        * 注意问题：
        * 问题⼀：剩下的链表个数不不够k个
        * 问题⼆：已经反转的链表与剩下的链表连接起来
    */
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(-1);
        Stack<ListNode> stack = new Stack<>();
        ListNode p = dummy;
        while(true){
            int count = 0;
            ListNode cur = head;
            while(cur != null && count < k){
                stack.push(cur);
                cur = cur.next;
                count++;
            }
            if(count != k){
                p.next = head;
                break;
            }
            //在把stack中的链表连起来
            while(!stack.isEmpty()){
                p.next = stack.pop();
                p = p.next;
            }
            p.next = cur;
            head = cur;
        }
        return dummy.next;
    }
}

方法二：进阶版本-》不使用额外的控件

翻转链表时候采用尾插法：

 -1 --> 1 --> 2 --> 3 --> 4 --> node
dummy
 pre
 tail
1.找到 tail 节点
 -1 --> 1 --> 2 --> 3 --> 4 --> node     
dummy                    tail  
pre
2.执行尾部插法
    -1 --> 2 --> 3 --> 4 --> 1 --> node (1)
     pre              tail
    -1 --> 3 --> 4 --> 2 --> 1 --> node (1)
    pre         tail  
    -1 --> 4 --> 3 --> 2 --> 1 --> node (1)
     pre  tail
//终止条件： pre.next != tail 说明当前 k 个节点遍历完成
class Solution {
    //找到需要翻转链表的 pre 节点 和 tail 节点，翻转 pre -- > tail 这一部分
    //尾插法：每次将 pre.next 节点插入到 tail 的后面
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy,tail = dummy;
        while(true){
            int count = 0;
            //1.找 tail 节点
            while(count < k && tail != null){
                tail = tail.next;
                count++;
            }
            //2.如果不满足k个，直接结束最后小于 k 个节点的翻转
            if(tail == null) break;
            //3.尾插法翻转链表
            ListNode newPre = pre.next;
            while(pre.next != tail){
                ListNode cur = pre.next;
                pre.next = cur.next;
                cur.next = tail.next;
                tail.next = cur;
            }
            pre = newPre;
            tail = newPre;
        }
        return dummy.next;
    }
}

83. 删除排序链表中的重复元素

请添加图片描述

递归代码：

class Solution {
    //递归版本
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) return head;
        head.next = deleteDuplicates(head.next);
        //如果head和next相等，直接返回head的next节点
        return head.val == head.next.val ? head.next : head;
    }
}

迭代版本：

class Solution {
    //迭代版本
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        while(head != null && head.next != null){
            if(head.val == head.next.val){
                head.next = head.next.next;
            }else{
                head = head.next;
            }
        }
        return dummy.next;
    }
}

160. 相交链表

请添加图片描述
方法：

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

206. 反转链表

请添加图片描述

递归版本：

class Solution {
    //递归版本
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode tail = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return tail;
    }
}

迭代版本：

class Solution {
    //迭代版本
    public ListNode reverseList(ListNode head) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = head;
        while(head != null && head.next != null){
            ListNode next = head.next;
            pre.next = next.next;
            next.next = dummy.next;
            dummy.next = next;
        }
        return dummy.next;
    }
}


class Solution {
    //迭代,头插入法
    public ListNode reverseList(ListNode head) {
        ListNode dummy = new ListNode(-1);
        while(head != null){
            ListNode next = head.next;
            head.next = dummy.next;
            dummy.next = head;
            head = next;
        }
        return dummy.next;
    }
}

445. 两数相加 II

请添加图片描述

方法：借助栈实现倒序相加

class Solution {

    //借助栈实现倒序相加，需要注意进位 问题
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<ListNode> stack1 = buildStack(l1);
        Stack<ListNode> stack2 = buildStack(l2);
        int ca = 0;
        ListNode dummy = new ListNode(-1);
        while(!stack1.isEmpty() || !stack2.isEmpty() || ca != 0){
            int a = stack1.isEmpty() ? 0 : stack1.pop().val;
            int b = stack2.isEmpty() ? 0 : stack2.pop().val;
            int sum = a + b + ca;
            ListNode node = new ListNode(sum % 10);
            node.next = dummy.next;
            dummy.next = node;
            ca = sum / 10;
        }
        return dummy.next;
    }

    public Stack<ListNode> buildStack(ListNode head){
        Stack<ListNode> stack = new Stack<>();
        while(head != null){
            stack.add(head);
            head = head.next;
        }
        return stack;
    }
}
北路向一
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题模板.pdf
04-05
1.4. LeetCode中二分查找题目 29 2. 双指针 30 2.1. 快慢指针 31 2.1.1. 什么是快慢指针 31 2.1.2. 快慢指针模板 31 2.1.3. 快慢指针相关题目 32 2.1.3.1. LC-141:链表是否有环 32 2.1.3.2. LC-142:环形链表入口 34 ...
java基础之Stack类
weixin_43146461的博客
10-13 245
(01) Stack实际上也是通过数组去实现的。 执行push时(即，将元素推入栈中)，是通过将元素追加的数组的末尾中。 执行peek时(即，取出栈顶元素，不执行删除)，是返回数组末尾的元素。 执行pop时(即，取出栈顶元素，并将该元素从栈中删除)，是取出数组末尾的元素，然后将该元素从数组中删除。 (02) Stack继承于Vector，意味着Vector拥有的属性和功能，Stack都拥有 /**...
LeetCode【HOT100＜一＞】
耀的博客
05-04 683
public int[] twoSum(int[] nums, int target) { int n = nums.length; for (int i = 0; i < n; i++){ for (int j = i + 1; j < n; j++){ if (nums[i] + nums[j] == target){ return new int[]...
链表的反转
JB666M的博客
04-26 242
链表的反转 在做一些题的时候需要将链表进行反转。一般有两种方法，使用栈和插入法。 1.栈：由于栈的特点是元素先入后出，那么将链表的元素压栈后再弹出就得到了反序。 代码如下： public ListNode ReverseList(ListNode head) { Stack<ListNode> stack = new Stack<>(); //遍历链表元素，并将个元素压栈 while (head!=null){
Leetcode打卡第三天
T_Tooony的博客
02-04 388
链表的增删查改
剑指Offrer_两个链表的第一个公共节点
JERRYFY007的博客
03-19 177
1.题目 输入两个链表，找出它们的第一个公共结点。 2.思路 采用2个栈，有公共节点的2个链表呈现Y型，两个链表分别入栈，再分别出栈，最后一个相等的节点，也就是正向的第一个公共节点。 3.代码 /* public class ListNode { int val; ListNode next = null; ListNode(int val) { ...
LeetCode刷题手册
最新发布
01-16
《LeetCode刷题手册》可能是一本指导如何有效刷题和提升算法编程能力的书籍。以下是可能包含在这本书中的主题： LeetCode介绍： 对LeetCode平台的简要介绍，包括网站功能、题目分类和评估系统。 算法基础： 提供...
leetcode:leetcode刷题记录与总结
04-05
leetcode刷题记录与总结 斑点与矩阵 详细说明 双指针 快慢指针 左右指针 二分查找 滑动窗口 初步和 分治 排序 链表 链表摘要批量操作 单年度查找/操作 树 二叉树前，后，层序等 二叉搜索树中序遍历，二分法等 字典树...
leetcode:开始LeetCode刷题之旅
04-27
密码开始LeetCode刷题之旅列表=====>开始于2015-09-06 <=====反向链表II 重新订购清单k组中的反向节点轮换清单排序清单成对交换节点=====>结束于2015-09-30 <====== 种类=====>从2015-10-08开始<===== 2个...
leetcode-python:leetcode刷题记录
04-12
排序类 ，引申：自然数组排序 重载python sort规则 查找类 （利用部分信息）二分查找，(利用所有... 链表中倒数第k个节点 链表双指针 剑指Offer 24. 反转链表 链表指针 剑指Offer 54. 二叉搜索树的第k大节点 二叉搜
两个链表的第一个公共结点（Java）
Sweet Baby，甜宝
08-24 1061
题目： 输入两个链表，找出它们的第一个公共结点。链表结点的定义如下： struct ListNode{ int m_nKey; ListNode* m_pNext; } 思路： 第一种解法：蛮力（暴力）法。 第二种解法：借助于栈的先进后出，由于找到两个链表的第一个公共结点，故这个链表在公共结点以后是一个Y字型，故我们将两个链表放入栈中，来找到栈中最后一个相同的结点，即为...
【leetcode】链表 && 双指针
myaijarvis notebook
01-13 184
简单 203. 移除链表元素 参考：203. 移除链表元素 - 力扣（LeetCode） 设置虚拟头节点，方便把删除头节点和非头节点的操作统一化 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * L
【刷题笔记】之牛客面试必刷TOP101（1）
m0_58761900的博客
08-23 1787
1. 反转链表（双链表头插法 / 栈） 2.链表内指定区间反转 3. 链表中的节点每k个一组翻转 4. 合并两个排序的链表 5. 合并k个已排序的链表
数据结构学习之栈、队列（JAVA）
qq_59263743的博客
04-27 1506
数据结构学习成果栈、队列学习成果分享： 此博客共分为两个部分：栈与队列 栈 基本概念：栈（stack）是限制插入和删除只能在一个位置上进行的表，即一种操作受限的特殊线性表。 图解： 栈顶：允许进行插入和删除的一端 栈底：固定的不允许进行插入和删除的一端 空栈：不含任何元素的空表 特性：后进栈的元素先出栈，栈又被称为后进先出表（LIFO——Last in , First out） Java实现： public class Stack<E> extends Vector
链表的相关方法
weixin_53310322的博客
01-20 1059
链表的相关方法1.虚拟头节点的设置2.设计链表 1.虚拟头节点的设置 在链表问题中，我们直接控制节点往往不好操作，往往需要设置一个虚拟头节点来模拟操作。 ListNode dummy = new ListNode(-1,head);//连接两个链表，且当前链表头值为-1 ListNode pre =dummy;//指针指向dummy 移除链表元素 class Solution { public ListNode removeElements(ListNode
初学算法的小菜鸡 - 自学笔记 (第十三天): 链表相关算法(三) 删除链表的倒数第N个节点 Leetcode 19题
qq_36751764的博客
04-01 377
初学算法的小菜鸡 - 自学笔记 (第十三天): 链表相关算法(三) 删除链表的倒数第N个节点 Leetcode 19题
栈的应用场景（高频面试题）
m0_64130230的博客
03-18 2429
栈高频面试题
labuladong刷题——第一章（1） 双指针技巧秒杀七道链表题目
qq_37772958的博客
09-13 337
双指针技巧秒杀七道链表题目
leetcode刷题顺序
07-27
根据引用\[1\]和引用\[2\]的内容，推荐的LeetCode刷题顺序是按照题目类型刷题，优先选择树、链表、二分查找、DFS、BFS、动态规划等常见类型的题目。可以先做2~4道简单题，然后再做中等难度的题目。在选择题目时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值