leetcode 链表(java)

最新推荐文章于 2025-01-15 18:00:00 发布
最新推荐文章于 2025-01-15 18:00:00 发布
阅读量287 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/GreenHand_D/article/details/107313402
版权

@[TOP](leetcode 链表)

leetcode160 链表相交（easy）

题目：
编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：
在这里插入图片描述
在节点 c1 开始相交。
坑：找相同内存地址的交点（同时相遇）而不是相同数字的节点

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        /**
        定义两个指针, 第一轮让两个到达末尾的节点指向另一个链表的头部, 最后如果相遇则为交点(在第一轮移动中恰好抹除了长度差)
        两个指针等于移动了相同的距离, 有交点就返回, 无交点就是各走了两条指针的长度
        **/
        if(headA == null || headB == null) return null;
        ListNode pA = headA, pB = headB;
        // 在这里第一轮体现在pA和pB第一次到达尾部会移向另一链表的表头, 而第二轮体现在如果pA或pB相交就返回交点, 不相交最后就是null==null
        while(pA != pB) {
            pA = （pA == null） ? headB : pA.next;
            pB = （pB == null） ? headA : pB.next;
        }
        return pA;
    }
}

leetcode206 反转链表（easy）

题目：反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

方法一：迭代

第一次循环：
在这里插入图片描述
第二次循环：
在这里插入图片描述

class Solution {
    public ListNode reverseList(ListNode head) {

        ListNode pre = null;  //指向当前节点的前一个节点
        ListNode cur = head;  //当前节点
        ListNode temp = null; //指向当前节点的下一个节点 

        while(cur != null){
            temp = cur.next;  //保存当前节点的下一个节点
            cur.next = pre;   //将当前节点指向pre
            pre = cur;        //将pre和cur都后移一位
            cur = temp;
        }
        return pre;  //最后的一个节点就是pre
    }
}

方法二：头插法

class Solution{
	public ListNode reverseList(ListNode head){
		ListNode newHead = new ListNode(-1);
		ListNode next = null;
		while(head!=null){
			next = head.next;  //保存后面的节点
			head.next = newHead.next;
			newHead.next = head;//插入到新头节点后面
			head = next;//节点后移一位
		}
		return newHead.next;
	}
}

方法三：递归

// 类似第一种迭代的方法
class Solution {
    ListNode pre = null, tmp = null;
    public ListNode reverseList(ListNode head) {
        if (head == null)
            return pre;
        tmp = head.next;
        head.next = pre;  
        pre = head;  //pre和head后移一位
        head = tmp;
        return reverseList(head);
    }
}

leetcode21 合并两个有序列表

方法一：递归

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;
        }
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
}

方法二：迭代(尾插法)

class Solution {   
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode newHead = new ListNode(-1);
        ListNode tail = newHead;  //由于头节点不能动，所以加一个指示指针
        if(l1 == null){
        	return l2;
        }
        if(l2 == null){
        	return l1;
        }
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                tail.next = l1;
                l1 = l1.next;
            } else {
                tail.next = l2;
                l2 = l2.next;
            }
            tail = tail.next;
            tail.next = l1 == null? l2: l1; //加入最后一个节点
        }
        return newHead.next;
    }
}

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

Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

方法一：迭代

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode temp = head;
        while( temp.next!= null){
            if(temp.next.val == temp.val){//需值相同，若不加val还有内存地址是不同的
                temp.next = temp.next.next; 
            }else{
                temp = temp.next;
            }
        }
        return head;
    }
}

方法二：递归

public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) 
    	return head;
    head.next = deleteDuplicates(head.next);
    return head.val == head.next.val ? head.next : head;
}

leetcode19 删除链表的倒数第N个节点

Given linked list: 1->2->3->4->5, and n = 2.
After removing the second node from the end, the linked list becomes 1->2->3->5.
双指针：快慢指针

  1. fast指针先移动n步
  2. slow和fast同时移动，二者间隔n，当fast移到最后一个节点时，slow即倒数第n个节点
public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode fast = head;
    while (n-- > 0) {   //相当于for循环，循环n次for(;n>0;n--)
        fast = fast.next;
    }
    if (fast == null) return head.next;   //删除头节点
    ListNode slow = head;
    while (fast.next != null) { //不包括删除第二个节点（head.next）
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;  //删除slow后面的节点
    return head;
}

leetcode24 两两交换链表中的节点(Medium)

Given 1->2->3->4, you should return the list as 2->1->4->3.
题目要求：不能修改结点的 val 值，O(1) 空间复杂度。

方法一：递归

  1. 找终止条件：当递归到链表为空或者链表只剩一个元素的时候，没得交换了，终止。
  2. 找返回值：返回给上一层递归的值应该是已经交换完成后的子链表。
  3. 单次的过程：因为递归是重复做一样的事情，所以只用考虑某一步是怎么完成的。假设待交换的俩节点分别为head和next，就相当于是一个含三个节点的链表交换前两个节点。
class Solution {
    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;  //把next放到head前面
        return next;  //返回每个子链的头节点
    }
}

方法二：迭代

//此处使用3个指针 pre,l1,l2
public ListNode swapPairs(ListNode head) {
    ListNode newHead = new ListNode(-1);
    newHead.next = head;
    ListNode pre = newHead;
    while (pre.next != null && pre.next.next != null) {
        ListNode l1 = pre.next;
        ListNode l2 = pre.next.next;
        
        l1.next = l2.next;
        l2.next = l1;
        pre.next = l2;

        pre = l1;
    }
    return newHead.next;
}

leetcode445 链表求和(Medium)

Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 8 -> 0 -> 7
7243+564 = 7807

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) { 
        Stack<Integer> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        
        while (l1 != null) {
            stack1.push(l1.val);
            l1 = l1.next;
        }
        while (l2 != null) {
            stack2.push(l2.val);
            l2 = l2.next;
        }
        int carry = 0;   //进位标志
        ListNode head = null;
        while (!stack1.isEmpty() || !stack2.isEmpty() || carry > 0) {
        //carry>0很重要，防止例如5+5=10时输出为0
            int sum = carry;
            sum += stack1.isEmpty()? 0: stack1.pop();
            sum += stack2.isEmpty()? 0: stack2.pop();
            ListNode node = new ListNode(sum % 10);
            node.next = head;   //头插法
            head = node;
            carry = sum / 10;
        }
        return head;
    }
}

leetcode234 回文链表（easy）

Example 1: Input: 1->2 Output: false
Example 2: Input: 1->2->2->1 Output: true
以 O(1) 的空间复杂度来求解

切成两半，把后半段反转，然后比较两半是否相等。

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null){
            return true;
        }

        ListNode fast = head.next;    //快慢指针
        ListNode slow = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
     
        ListNode cutHead = cut(head,slow.next);
        return isEqual(head,reverse(cutHead));
    }

    private ListNode cut(ListNode head,ListNode cutHead){
        while(head.next != cutHead){
            head = head.next;
        }
        head.next = null;
        return cutHead;
    }

    private ListNode reverse(ListNode head){   //头插法
        while(head == null || head.next == null){
            return head;
        }
        ListNode newHead = null;
        ListNode nextNode = null;
        while(head!=null){
            nextNode = head.next;
            head.next = newHead;
            newHead = head;
            head = nextNode;
        }
        return newHead;
    }
    private boolean isEqual(ListNode l1,ListNode l2){
        while(l1 != null && l2 != null){
            if(l1.val != l2.val){
                return false;
            }else{
                l1 = l1.next;
                l2 = l2.next;
            }
        }
        return true;
    }
}

leetcode725 分隔链表（Medium）

Input: root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
输入被分成了k个连续的部分，并且每部分的长度相差不超过1.前面部分的长度大于等于后面部分的长度。

Example 1：
Input: root = [1, 2, 3], k = 5 Output: [[1],[2],[3],[],[]]
输入输出各部分都应该是链表，而不是数组。
Example 2: 输入的结点 root 的 val= 1, root.next.val = 2, \root.next.next.val = 3, 且 root.next.next.next = null。
第一个输出 output[0] 是 output[0].val = 1, output[0].next = null。
最后一个元素 output[4] 为 null, 它代表了最后一个部分为空链表。

思路：

  1. 遍历链表获取长度 length
  2. length 除以 k 得到每段链表的平均长度 aveLength 和 余数 remainder，remainder 的值就是有多少个长度为 (aveLength + 1) 的子链表排在前面。
    举个例子帮助理解一下 11 / 3 = 3 余 2： 一共有3段，每段平均3个节点，但是剩下了2个节点，剩下的2个节点不能丢啊，得全部塞到子链表里面去。根据题意长的链表排前面，短的链表排后面，所以只有前面的两个子链表一人分担一个多余的节点，如此一来便形成了 4 4 3 的结构。
  3. 接下来按照每个子链表应该的长度[4, 4, 3]去截断给定的链表。
public ListNode[] splitListToParts(ListNode root, int k) {
        int length = 0;
        ListNode cur = root;

        while(cur != null){   
            length++;
            cur = cur.next;
        }
        int avgSize = length / k;   //平均长度
        int mod = length % k;   //余数
        ListNode[] res = new ListNode[k];
        
        cur = root;
        for(int i = 0 ; cur != null && i < k ; i++){
            res[i] = cur;
            int size = avgSize + (mod-- >0 ? 1:0);
            for(int j = 0 ; j < size-1;j++){
                cur = cur.next;
            }
            ListNode next = cur.next;   //保存每个子链表的头节点
            cur.next = null;    //分隔
            cur = next;
        }
        return res;
    }

leetcode328 链表元素按奇偶聚集（Medium）

Input: 2->1->3->5->6->4->7->NULL
Output: 2->3->6->7->1->5->4->NULL
应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。

思路：将奇节点放在一个链表里，偶链表放在另一个链表里。然后把偶链表接在奇链表的尾部

public class Solution {
    public ListNode oddEvenList(ListNode head) {
        if (head == null) return null;
        ListNode odd = head, even = head.next, evenHead = even;
        while (even != null && even.next != null) {
            odd.next = even.next;
            odd = odd.next;
            even.next = odd.next;
            even = even.next;
        }
        odd.next = evenHead;
        return head;
    }
}
GreenHand_D
关注
【力扣LeetCode】java算法刷题大全第8题之环形链表
小米吃辣椒的博客
04-28 1661
一、给定一个链表，判断链表中是否有环 /** * 当存在环形的条件下，快慢指针形成了一个龟兔赛跑的模型，如果两个指针指向了 * 同一个元素，说明存在环形，返回true * 解法一：快慢双指针 * * @param head * @return */ public boolean hasCycle(ListNode head) { if (head == null) return false;
LeetCode 链表两数相加⭐️
铁马冰河入梦来
08-12 1558
给你两个的链表，表示两个非负的整数。它们每位数字都是按照的方式存储的，并且每个节点只能存储数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
LeetCode 链表题 ( Java )
大数据的奇妙冒险
02-16 702
通俗易懂总结常见链表题
leetcode java 链表
weixin_51666505的博客
05-10 275
删除链表的倒数第 N 个结点 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val,...
LeetCode排序链表（JAVA）
weixin_43589025的博客
06-03 360
问题： 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4->5 代码实现 public class 排序链表 { public static void main(String[] args) { ListNode no
Leetcode刷题系列java版-----链表(简单)
qq_39687662的博客
07-21 421
我写的这个系列的博客解题的算法不一定是时间和空间复杂度最优的解,一切以能AC+算法模板普适性为原则解题 首先是链表的增删改查,所有问题都是以链表的增删改查为核心去变种的,改和查按照条件去遍历链表即可,下面直接看leetcode原题: 1.移除链表元素(链表删除节点的模板题) 要点: ①进来一定要先记得判空,在访问next的时候也一定要注意代码是否会造成空指针异常,如果一个类比如ListNode题中的两个属性val和next,如果当前节点node为null,那么访问val和next的时候都会报空指.
LeetCode100之排序链表(148)--Java
最新发布
2301_79318558的博客
01-15 741
这道题，我们采用归并排序的方法来进行链表的排序，唯一要值得注意的点就是，在切分小链表时，尾指针的初始化值要初始化为头指针的下一个节点，这样递归调用时才不会陷入死循序。
leetcode-java
03-21
leetcode-java 课程1：Java入门与基础算法 Fizz Buzz-> Java语言 字符串和数组 类和对象 参考 界面 数据结构： 链表 栈 阴离子 树 哈希表 算法： 枚举 递归 分治 排序 在IDE里打印输出，并输出分行-> System.out....
本地IDE调试LeetCode中链表相关问题
hesongzefairy的博客
03-05 2768
当我们想在本地的IDE调试LeetCode代码时，直接复制代码来调试肯定会出问题，链表相关的问题在LeetCode上内部封装了其节点类，所以我们在本地调试的时候，需要自己添加节点类才能正常调试。 首先看LeetCode上关于链表的题目是如何给的： /** * Definition for singly-linked list. * public class ListNode { * ...
【经典算法】LeetCode 148. 排序链表(Java/C/Python3实现含注释说明,中等)
2401_84427485的博客
04-25 1239
方式优点缺点时间复杂度空间复杂度插入排序链表实现简单直观时间复杂度较高，为O(n^2)O(n^2)O(1)归并排序链表时间复杂度较低，为O(n log n)需要额外空间进行递归或合并操作O(n log n)O(n) 或 O(log n)（原地归并）注意：这里的空间复杂度是相对于链表本身大小n而言的。插入排序是原地排序，不需要额外空间（除了常数级别的空间），所以空间复杂度为O(1)。
循环单链表搜索子链
01-08
数据结构题目，CirSinglylyList双链表类的成员方法 Void replaceAll(CirSinglyListpattern, CirSinglyListlist) 替换所有与pattern匹配的子表为list，Node节点类需自行编写
Leetcode链表题（Java作答）
qq_45384304的博客
06-11 250
83.删除排序链表中的重复元素 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 示例1: 输入: 1->1->2 输出: 1->2 示例2: 输入: 1->1->2->3->3 输出: 1->2->3 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list /** * Definition for...
707. 设计链表
quekai01的博客
11-30 302
707. 设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索...
leetcode 链表操作 java
weixin_51666505的博客
05-08 364
移除链表元素 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; }
Leetcode—链表专题(java版本)
qq_42265220的博客
09-13 615
链表专题一、链表简介链表的基操 一、链表简介 各种数据结构，不管是队列，栈等线性数据结构还是树，图的等非线性数据结构，从根本上底层都是数组和链表。不管你用的是数组还是链表，用的都是计算机内存，物理内存是一个个大小相同的内存单元构成的，如图： 而数组和链表里的数据虽然用的都是物理内存，都是两者在对物理内存的使用上是非常不一样的，如图： 数组是连续的内存空间，通常每一个单位的大小也是固定的，因此可以按下标随机访问。而链表则不一定连续，因此其查找只能依靠别的方式，一般我们是通过一个叫 next 指针来遍历查找
LeetCode链表算法题（java版）
Vae的黑粉
11-25 1307
文章目录前言一、倒数第k个节点二、1.2.总结 前言 在写链表的算法题之前先手撕一下链表的几个基本功能吧。（一定要多练习！！！） class Node{ public int data; public Node next; public Node(int data){ this.data = data; } } public class SingleLinkedList { public Node head; //头插法
LeetCode 链表解题汇总 Java版
weixin_34219944的博客
04-21 298
19. Remove Nth Node From End of List (Medium) 移除倒数第N个节点 19. Remove Nth Node From End of List 代码： 先判断经过n个节点后是否刚好到了末尾，是的话链表长度为n，第n个节点就是头结点，直接返回head.next的链表。 经过n个节点后，还未到末尾，此时开启双指针，slow和fast同时往后走，fast和s...
leetcode——合并两个有序链表（java版）
lingle1的博客
02-20 469
文章目录题目解答1：解答2： 题目 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 解答1： class Solution { public ListNode mergeTwoLists(ListNode...
Leetcode-JAVA版本链表专题学习
qq_51517771的博客
04-23 370
链表002两数相加代码（对应结点相加）019删除链表的倒数第N个结点代码一（倒数转正数）代码二（学习双指针）代码三（利用数组）021合并两个有序链表代码一（遍历链表）代码二（学习递归，暂时不会）023合并K个升序链表代码一（利用数组）代码二（学习优先队列，暂时不会）代码三（学习分治算法，暂时不会）024两两交换链表中的节点代码一代码二（学习递归，暂时不会）代码三（学习迭代，暂时不会）025K个一组链表翻转代码一代码二（学习递归，暂时不会）代码三（学习迭代，暂时不会） 002两数相加 代码（对应结点相加） /
掌握LeetCode链表问题的Java解决方案
但根据文件标题和描述的内容，我们可以推断，文件中的内容可能是关于如何使用 Java 来解决 LeetCode 上与链表相关的编程题目。 具体到文件压缩包的文件名称列表中提到的 leetcode-master，这似乎是一个包含 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值