LeeCode链表习题训练合集

最新推荐文章于 2023-01-04 18:34:45 发布
最新推荐文章于 2023-01-04 18:34:45 发布
阅读量100 收藏
点赞数
分类专栏： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44715697/article/details/108623056
版权
Leetcode 21. 合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表时通过拼接给定的两个链表的所有节点组成的。

示例：
在这里插入图片描述

/**
 * 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 mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode(-1);		//创建一个表头用来存储合并之后的链表
        ListNode p = l3;		//定义一个指针指向新链表的表头
        while(l1!=null&&l2!=null)	//循环遍历两个旧链表
        {
        	//两个链表中的结点相比较，将数据较小的结点存入新链表中
            if(l1.val >= l2.val)	
            {
                  p.next = l2;
                  l2 = l2.next;
            }
            else
            {
                p.next = l1;
                l1 = l1.next;
            }
            p = p.next; 
        }
        p.next = l1 == null ? l2 : l1;		//两个旧链表中肯定有一个率先遍历完，这时只需要将另一个链表中所有结点顺序存入新链表中就可以了
        return l3.next;		//这里的next是因为在初始化新链表时首元结点赋值为-1，我们不需要这个首元结点
    }
}
leetcode 83. 删除排序链表中的重复元素

给定一个排序链表，删除所有的重复元素，使得每个元素只出现一次。
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode p = head;		//创建一个临时指针用来操作
        while(p != null && p.next!=null)	//遍历链表，当一个结点与它之后的一个结点不为空时
        {
            if(p.val == p.next.val)		//如果连续两个结点的值相等
            {
                p.next = p.next.next;	//删除相等结点
            }
            else
            p = p.next;
        }
        return head;		//返回头指针地址
    }
}
Leetcode 141.环形链表

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
    	//用一个Set集合来存储节点数据
        Set<ListNode> set = new HashSet<>();
        while(head != null){
        	//在遍历节点的过程中，如果集合中已经存在这个节点，就说明有环，返回true
            if(set.contains(head))
            return true;
            else
            //如果没有，则将其添加进集合中
            set.add(head);
            head = head.next;
        }
        return false;
    }
}

//我们再来用双指针来解这道题
public class Solution{
	public boolean hasCycle(ListNode head){
		//当只有头节点或没有节点时，返回false
		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;
			slow = slow.next;
			fast = fast.next.next;
		}
		return true;
	}
}
Leetcode 160. 相交链表

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

如下面的两个链表：

在这里插入图片描述

在节点 c1 开始相交。

/**
 * 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) {
        if(headA==null || headB==null)
        return null;
        ListNode pa = headA;
        ListNode pb = headB;
        while(pa != pb){
            pa = pa != null ? pa.next : headB;
            pb = pb != null ? pb.next : headA;
        }
        return pa;
    }  
}

这道题可以采用双指针的方法来解决。虽然两个链表长度不相等，但是两个链表长度的和是相等的。当遍历链表A时，如果结束则返回链表B的头节点；遍历链表B时，如果结束则返回链表A的头节点。假如两个链表相交，则一定在末尾的一段是一样的，所以就一定会同时到达交点。而如果没有相交，则两个链表同时到达末尾。

Leetcode 203.移除链表元素

删除链表中等于给定值 val 的所有节点。
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
    	//设置一个虚拟头节点
        ListNode ph = new ListNode(-1);
        ph.next = head;
        //设置一个指针用来遍历整个链表
        ListNode p = ph;
        //遇到相等的值就删掉，否则继续遍历
        while(p.next!=null){
            if(p.next.val == val){
                p.next = p.next.next;
            }
            else
            p = p.next;
        } 
        //因为头结点赋值为-1，所以返回ph.next
        return ph.next;
    }
}
LeetCode 206.反转链表

反转一个单链表。
在这里插入图片描述

运用迭代法
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode curr = head;	//定义指向当前结点的指针
        ListNode prev = null;	//定义一个空指针指向当前结点的前一个结点
        while(curr != null){
            ListNode temp = curr.next;	//当前结点的后一个结点
            curr.next = prev;	//当前结点指向前一个结点
            prev = curr;	//这两步是指针移动，前一个结点和当前结点都往后移动一位
            curr = temp;
        }
        return prev;	//返回新的头引用
    }
}
运用递归法
class Solution {
    public ListNode reverseList(ListNode head) {
    	//	递归结束条件
        if(head==null || head.next==null)
        return head;
        ListNode p = reverseList(head.next);
        //当前指针要指向前一个结点
        head.next.next = head;
        //将原来的指向下一个结点的指针删除，否则会造成循环
        head.next = null;
        return p;
    }
}
LeetCode 234.回文链表

请判断一个链表是否为回文链表。

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
    	//维护一个对象类型的数组
        List<Integer> arrs = new ArrayList<>();
        ListNode p = head;
        //将链表中的数据装进数组中
        while(p != null){
            arrs.add(p.val);
            p = p.next;
        }
        //定义两个指针，一头一尾
        int begin = 0;
        int end = arrs.size()-1;
        //遍历整个数组，当两个指针所指向的数据不相等时则不是回文链表
        while(begin<end){
            if(!arrs.get(begin).equals(arrs.get(end)))
            return false;
            begin++;
            end--;
        }
        return true;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null)
        return true;
        //寻找中间结点
        ListNode firstHalfEnd = findmid(head);
        //反转前半部分链表
        ListNode secondHalfStart = reverse(firstHalfEnd.next);
        //将链表后半段进行反转之后，比较两部分链表的值，如果都相等则是回文链表
        ListNode p1 = head;
        ListNode p2 = secondHalfStart;
        while(p2 != null){
            if(p1.val != p2.val)
            return false;
            p1 = p1.next;
            p2 = p2.next;
        }
        //最后要将反转的后半段再恢复原样
        firstHalfEnd.next = reverse(secondHalfStart);
        return true;   
    }

	//定义寻找中间结点的函数
    private ListNode findmid(ListNode head){
    ListNode fast = head;
        ListNode slow = head;
        while(fast.next!=null && fast.next.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
	
	//定义反转链表函数
    private ListNode reverse(ListNode head){
    ListNode prev = null;
    ListNode curr = head;
    while(curr != null){
        ListNode temp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = temp;
    }
    return prev;
    }

}
LeetCode 237.删除链表中的结点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

在这里插入图片描述

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
 //思路就是把要删除的结点的值赋给下一个结点的值，然后再删除这个结点就可以了。
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}
LeetCode 876.链表的中间节点

给定一个带有头结点head的非空单链表，返回链表的 中间结点。
如果由两个中间结点，则返回第二个中间节点。

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
	//整体思路就是用快慢双指针遍历链表，当快指针遍历到最后一个链表的时候，慢指针正好遍历到中间节点
    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;
    }
}
LeetCode 1290.二进制链表转整数

给你一个单链表的引用结点head。链表中每个结点的值不是0就是1.已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的十进制值。

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
 //就是简单的二进制转十进制的方法
class Solution {
    public int getDecimalValue(ListNode head) {
        ListNode p = head;
        int ans = 0;
        while(p != null){
            ans = ans*2 + p.val;
            p = p.next;
        }
        return ans;
    }
}
吗吗哈哈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode-链表
Ritchie_Lin的博客
04-22 303
String Tree 783. 二叉搜索树节点最小距离 给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。 解析： 如果对节点的值进行排序，那某个值与其相邻的两个值的差值中的最小值就是该值与其它值差值的最小值，那实际上只要对排序后的值进行遍历，就可以找出最小值。 给定的树是二叉搜索数，即对于每个节点，父节点的值大于左子节点的值，且小于右子节点的值。所以如果对其进行中序遍历，那遍历的值是升序的。 所以解题思路就是先对二叉树进行中序遍历，将节点的值保存到数组中，此时，数组
算法训练—leetcode—链表篇
歪桃的博客
10-20 6878
本文涉及的leetcode对应的题 leetcode第876题链表的中间节点 leetcode第160题相交链表 leetcode第237题删除链表当前节点 leetcode剑指offer18题删除链表中的某个节点 leetcode第19题删除链表的倒数第N个节点 leetcode第141题环形链表 I leetcode第142题环形链表 II leetcode第1290题二进制链表转整数 leetcode第206题反转一个单链表 leetcode第24题两两交换链表中的节点 leetcode第21题合并两
leetcode--链表
qq_41451702的博客
06-20 346
链表：单链表、双链表、循环链表。链表和数组区别：203 移除链表元素c++使用链表删除元素后要delete该元素的内存空间方法一：如果头节点是需要删除的元素，需要将head = head->next 方法二： 设置一个虚拟头节点(需要初始化)，让这个虚拟头节点的next = head，最后记得让head = 虚拟头节点的next,然后删除虚拟头节点 707 设计链表对于数组遍历只需要知道它的长度，对于链表长度未知，只能一个一个节点去找，直到某个节点的next = null 206 反转链表双指针
【LeetCode之链表】
Liususiu的秃头日记
11-12 456
LeetCode链表系列常见的题目。
【LeetCode】-链表
银尘博客
01-27 718
文章目录一、移除链表元素二、设计链表 一、移除链表元素 题目： 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 示例 2： 输入：head = [], val = 1 输出：[] 示例 3： 输入：head = [7,7,7,7], val = 7 输出：[] 提示： 列表中的节点数目在范围 [0, 10
链表练习题(修正)1
08-08
这些练习题涵盖了链表的基本操作，对于学习和理解链表至关重要。在实际编程中，链表常用于动态数据结构，如队列、栈或者实现高级数据结构如图和树。掌握链表的插入、删除和遍历等操作，能帮助我们更好地解决复杂问题...
Java算法练习-环形链表插值练习题
10-01
java学习
Java算法练习-链表的分化练习题
最新发布
10-07
java
C语言题库数组，指针，结构体，链表习题
12-28
整理的一些关于C语言的练习题，题目答案都有，需要的可以下载看一下
双链表模拟集合练习题.txt
06-14
java实现双链表模拟集合练习题
LeetCode——链表篇
Pcl2001的博客
03-11 1595
LeetCode——链表篇一、移除链表元素题解代码二、反转链表题解代码三、两两交换链表中的节点题解代码四、删除链表的倒数第 N 个结点题解代码五、相交链表题解代码六、环形链表题解代码七、环形链表 ||题解代码 一、移除链表元素 题解 该题其实就只需要遍历一下链表，需要注意的是，做这种题目的时候，最好新建一个头结点，否则在执行删除操作的时候难以进行。删除操作是链表中最基本的操作，需要熟练掌握。 代码 # Definition for singly-linked list. # class ListNode:
leetcode | 链表
Data Hero
01-04 445
链表基础知识和力扣相关算法题解
LeetCode之链表
qq_38773342的博客
11-19 679
1 反转链表 给定一个单链表的头结点pHead，长度为n，反转该链表后，返回新链表的表头。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 truct ListNode* ReverseList(struct ListNode* pHead ) { if(pHead == NULL || pHead->next == NULL){ return pHead; } struct ListNode *p
leetcode 之 链表
Luckyzhoufangbing的博客
12-02 195
1. 链表中倒数第 K 个节点 设置快慢两个指针，首先他们 都是 head，快的先走 k - 1 步，然后快慢一起走，一步一步走，快的走到终点，此时慢的就是所求的值 var kthToLast = function(head, k) { var showLink = head var fastLink = head // 快指针先走k-1步 while (k > 1) { fastLink = fastLink.next k-- } // 当快指针到达
Leetcode——链表
weixin_48367136的博客
09-16 1073
Leetcode——链表合并两个有序链表删除排序链表中的重复元素环形链表相交链表移除链表元素反转链表回文链表删除链表中的节点 链表（Linked List）是最简单的线性的、动态数据结构。理解它是理解树结构、图结构的基础。 区别于数组，链表中的元素不是存储在内存中连续的一片区域，链表中的数据存储在每一个称之为「结点」复合区域里，在每一个结点除了存储数据以外，还保存了到下一个节点的指针（Pointer）。 由于不必按顺序存储，链表在插入数据的时候可以达到 O(1)O(1) 的复杂度，但是查找一个节点或者访问特
leetcode链表
qq_43283527的博客
04-03 356
例题 2. 两数相加 代码如下： # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def addTwoN...
LeetCode 链表总结
qq_41605114的博客
04-12 844
两个基本操作 两种删除方法： 两种插入方法： 双指针： 快慢指针： 先入后出： 递归：
LeetCode——链表
weixin_45859425的博客
04-10 120
两数相加 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头 示例1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例3： 输入：l1 = [9,9,9,9,9,9,
剑指LeetCode -- 第七百零七题 -- 设计链表 -- 简单
蛋蛋
10-03 402
class MyLinkedList { private final ListNode list; private ListNode head; private ListNode rear; private int length; /** Initialize your data structure here. */ publ...
K - 双向链表练习题
03-25
A：好的，下面是K - 双向链表练习题的解答。 题目描述： 设计一个数据结构，要求实现双向链表的基本操作：插入、删除、反转等，并实现一个方法向链表中添加一个元素。同时，该数据结构需要支持以下操作： 1. get...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值