链表的实现及其相关习题

已于 2022-04-11 21:58:31 修改
阅读量233 收藏 1
点赞数 2
文章标签： 数据结构 链表 java 算法
于 2021-01-10 12:30:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asfsaf21/article/details/112426497
版权
本文介绍了链表的基本实现，并详细讲解了如何解决LeetCode中的链表相关问题，包括反转链表、回文链表、环形链表、删除指定元素、相交链表和合并有序链表等经典题目，强调掌握链表操作的重要性以及解题思路的独特性。
摘要由CSDN通过智能技术生成

@TOC链表的实现及其相关习题

前言

1.链表的实现:

		下文我通过递归实现
		(在寻找Last元素时while循环也是可以的）

2.常见链表相关习题：【均来自LeetCode题库】

		（1）反转链表。
		
		（2）回文链表
		
		（3）环形链表
		
		（4）删除链表指定元素
		
		（5）相交链表
		
		 (6)合并两个有序链表（排好序的）
二、常见链表相关习题:

1.单向链表的实现

public class MyLinkList{
    //头节点
    private LinkNode first=new LinkNode(null,null);
    private int sive;
    //添加元素
    public MyLinkList(){}
    // 添加元素
    public void add(Object obj){
        if(first.next==null){
            first.next=new LinkNode(obj,null);
        }else{
            LinkNode lastNode=SearchlastNode(first.next);
            lastNode.next=new LinkNode(obj,null);
        }
        sive++;
    }
    private LinkNode SearchlastNode(LinkNode first){
        LinkNode node=first;
        while(true){
            if(node.next==null){
                return node;
            }
            node=node.next;
        }
    }
    // 在头节点增加元素
    public void addHeadNode(Object obj){
        if (first.next==null){
            add(obj);
        }else {
            first.next=new LinkNode(obj,first.next.next);
        }
        sive++;
    }
    // 删除头节点
    public boolean deleteHeadNode(){
        if(first.next==null){
            return false;
        }else {
            first.next=first.next.next;
            sive--;
            return true;
        }
    }

    // 查询链表中元素的个数
    public int size(){
        return this.sive;
    }
    // 删除指定元素
    public boolean delete(Object obj){
        if(first.next==null){
            return false;
        }
        LinkNode node=first.next;
        while(node!=null){
            if(obj.equals(node.date)){
                return true;
            }
            node=node.next;
        }
        return false;
    }
    // 在指定元素后增加新元素
    public boolean appointAdd(Object obj,Object newobj){
            if(first.next==null){
                return false;
            }

            LinkNode node=first.next;
            while(node!=null){
                if(obj.equals(node.date)){
                    if(node.next==null){
                        node.next=new LinkNode(newobj,null);
                        return true;
                    }
                    node.next=new LinkNode(newobj,node.next.next);
                    return true;
                }
                node=node.next;
            }
            return false;
    }
}

class LinkNode {
    public Object date;
    public LinkNode next;
    public LinkNode(Object obj, LinkNode next){
        // 是梦开始的起点也是 所有过程的必经之路！！
        this.next=next;
        this.date=obj;
    }
    @Override
    public String toString() {
        return (String) date;
    }
}

2.链表相关习题

(1).反转链表：(LeetCode题目编号：206)
这里我采用三指针移动的方法解决（当然也可以暴力递归或者循环）
如图：
在这里插入图片描述
在这里插入图片描述

代码如下：

* public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }

class Solution {
	public ListNode reverseList(ListNode head) {
		return help(head);
    }
    public ListNode help(ListNode head){
            if(head==null || head.next==null)return head;
            if(head.next.next==null){
                ListNode jj=head;
                ListNode ii=jj.next;
                ii.next=jj;
                jj.next=null;
                return ii;
            }
            ListNode i,j,t;
            i=head;
            j=head.next;
            t=head.next.next;
            i.next=null;
            while(true){
                j.next=i;
                i=j;
                if(t==null)break;
                j=t;
                t=t.next;
            }
            return j;
    }
}

还可以暴力递归 你们随便看看就行（虽然也可以但是空间,时间复杂度都比较大）
简单来说就是先遍历存储到栈中再递归弹栈形成反转链表newhead
在这里插入图片描述

class Solution {
     ListNode   newhead;
     Stack<ListNode> stack;
    public ListNode reverseList(ListNode head) {
         if(head==null)return null;
         Stack<ListNode> stack=new Stack<>();
         while(head!=null){
             stack.push(head);
       	     head=head.next;
         }
         this.stack=stack;
         this.newhead=this.stack.pop();
         return digui(newhead);
    }
     public ListNode digui(ListNode head){
        if(!this.stack.isEmpty()){
             head.next=this.stack.pop();
             return digui(head.next); 
         }else{
            head.next=null;
             return this.newhead;
         }
     }
}

（2）回文链表：(LeetCode题目编号：234)

1.先展示一个效率比较低但是很好理解的方法：（效率高的版本博主尚未理解和哈哈哈哈实现嘻嘻！）

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
    //new一个双端队列   
        ArrayDeque<ListNode> deque=new ArrayDeque<>();
        //将链表中的元素循环存入双端队列中
        while(head!=null){
            deque.addFirst(head);
            head=head.next;
        }
        //再 循环出列判断首尾是否一致  若不一致则直接返回false
        while(!deque.isEmpty()){
        /*
        这里我们需要考虑到最后firs出列和last出列为同一个对象的情况   
        相当于正好走到了队列的正中央 

		removeFirst（）方法会检索队列首元素并删除
		getFirst（）方法会检索队列首元素但不删除
		removeLast()与getLast()同理
		*/
            if(deque.getFirst()==deque.getLast())return true;
            if(deque.removeFirst().val != deque.removeLast().val) return false;
        }
        return true;
    }
}

（3）环形链表：(LeetCode题目编号：141)
这一题配图会好理解一些：
在这里插入图片描述

		这一题咋们不得不说快慢指针了：（以下是我形象的解释哈哈哈）
			假设乌龟和兔子起点都在头节点						
    快慢指针：
            乌龟跑的慢  所以   乌龟是后进入环的
            兔子跑的快  所以   兔子是先进入环的
            当两者都进入环
            **兔子一定会追乌龟（因为兔子跑的快嘛！！）
            当乌龟与兔子相遇则
            存在环
            若兔子走到了null（如果没环那大家都没进入环  最终都走到了最后一个节点 next==null；）
            则无环
 
						代码如下：（实力有限，我写的并不太简洁）

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    LinkedList list=new LinkedList();
    public boolean hasCycle(ListNode head) {
        ListNode l1=head;
        if(l1==null){
return false;
        }
        ListNode l2= head.next;
        if (l2==null ||l2.next==null || l2.next.next==null){
            return false;
        }
        
        while(true){
            if (l2.next==null || l2.next.next==null){
                return false;
            }
            if(l1.equals(l2)){
                return true;
            }
            l1=l1.next;
            l2=l2.next.next;
        }
    }
}

（4）删除链表指定元素：(LeetCode题目编号：203)
我是暴力递归可能有点难理解 需要你细心阅读
当然也可以循环实现 （博主脑子中毒了）
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    int val;
    ListNode head;
    public ListNode removeElements(ListNode head, int val) {
            this.head=head;
            this.val=val;
            // 一个都没有
            if(head==null){
                return head;
            }
            // 正好只有一个
            if(head.next==null){
                if(head.val==val){
                    head=null;
                    return head;
                }
                return head;
            }
            // 两个及两个以上
            return removeElementsGo(head);
    }
    public ListNode removeElementsGo(ListNode head){
        if(head==null){
            return this.head;
        }
        if(this.head.val==this.val){
            this.head=head.next;    
            head=null;
            return removeElementsGo(this.head);
        }
        if(head.next==null && head.val==this.val){
                head=null;
                return this.head;
        }else if(head.next==null){
                return this.head;
        }
        if(head.next.val==this.val){
            head.next=head.next.next; 
            return removeElementsGo(head);
        }else{
            return removeElementsGo(head.next);
        }
    }
}

(5)相交链表：(LeetCode题目编号：160)

	这一题也上图吧：

在这里插入图片描述
我也是暴力解法嘻嘻：
意思就是 先算每个链表的长度n1,n2 再让较长的链表先走|n1-n2|步
然后同起点进行逐个判断是否相交 如果不相交 最终都走到尾节点 next=null;

在这里插入图片描述

代码如下：

/**
 * 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;
        int a=length(headA);
        int b=length(headB);
        if(a>b){
            return getIntersectionNodeGo(headA,headB,a,b);
        }else if(a<b){
            return getIntersectionNodeGo(headB,headA,b,a);
        }else{
            ListNode i=headA;
            ListNode j=headB;
            while(true){
                if(i==null || j==null){
                    return null;
            }
                if(i.equals(j)){
                    return i;
            }
                
                i=i.next;
                j=j.next;
            }
        }
    }
    public int length(ListNode head){
        int length=0; 
        while(head!=null){
            length++;
            head=head.next;
        }
        return length;
    }
    public ListNode getIntersectionNodeGo(ListNode headA, ListNode headB,int a,int b){
        ListNode i=headA;
        ListNode j=headB;
        while(true){
              i=i.next;
              a--;
              if(a==b)break;
        }
        while(true){
            if(i==null || j==null){
                return null;
            }
            if(i.equals(j)){
                return i;
            }
            i=i.next;
            j=j.next;
        }
    }
}

(6)合并两个有序链表：(LeetCode题目编号：21)
这一题递归实现 代码十分简洁
可以这么理解我的解法：
先是递归描点（排好序的点【节点】） 然后return是连线的过程

在这里插入图片描述

在这里插入图片描述

			代码如下：

/**
 * 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){
         if(l1 == null) { return l2; }
        if(l2 == null) { return l1; }
        ListNode ll=l1.val<l2.val? l1:l2;
        if(l1.val>=l2.val){
            ll.next=mergeTwoLists(ll.next,l1);
        }else{
            ll.next=mergeTwoLists(ll.next,l2);
        }
        return ll;
    }

}

总结

你需要掌握

1.熟练的实现链表 信手拈来

2.掌握常见题型的 基本解法 一定要有自己的想法 和理解 即使你看不懂别人写的

3.我为实现的高效率版本 回文链表判断 你可以写完教我 私信我嘻嘻！！

4.谢谢你的观看噢！（学累了吧来看点治愈人心的图片）
在这里插入图片描述

别冲了！保重！

我先冲了xdm
关注
链表的练习题
TheDevice的博客
03-14 530
1.删除链表中等于给定值val的所有节点。 2. 反转一个单链表。 3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 4. 输入一个链表，输出该链表中倒数第k个结点。 5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的
链表相关题目
破浪会有时的博客
08-05 170
这里会总结一点链表相关的题目来供自己复习 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 提示： 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1
链表习题
Elegdawnce的博客
09-03 478
在这两个数据文件中，1.dat文件中的用餐记录数据已经按照用餐金额进行了增序排列。请按要求完成如下操作：   1.        编写一个函数，读取1.dat文件中的所有用餐记录数据，并构建一个用餐记录链表。 2.     编写一个函数，在屏幕上显示第1步中生成的用餐记录链表中的所有数据，要求每行输出1条记录，显示内容和格式要求如下： 学生学号 占25列，左对齐
链表简单习题
qq_49425839的博客
08-18 228
链表反转 给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点 链表为空，返回头节点 定义两个结点 pre 为 null ，cur指向头节点 遍历链表时，定义临时结点存放 cur 的下一结点，同时让 cur 指向 pre 因为要向后遍历，pre 向后移到 cur 的位置，cur 移到刚刚定义的临时结点位置 （达到链表反转效果） …（以此循环） 最后因 cur == null 跳出循环， pre 在cur 的前一位，所以返回 pre 即可 class Sol.
16种链表的练习
08-17
16种链表的练习 1.c 有头 无序 不循环 单向 2.c 有头 有序 不循环 单向 3.c 无头 无序 不循环 单向 4.c 无头 有序 不循环 单向 5.c 有头 无序 循环 单向 6.c 有头 有序 循环 单向 7.c 无头 无序 循环 单向 8.c 无头 有序 循环 单向 9.c 有头 无序 不循环 双向 10.c 有头 有序 不循环 双向 11.c 无头 无序 不循环 双向 12.c 无头 有序 不循环 双向 13.c 有头 无序 循环 双向* 14.c 有头 有序 循环 双向 15.c 无头 无序 循环 双向 16.c 无头 有序 循环 双向 listVerOutput.c 将有头 无序 不循环 单向链表的指针指向逆序并输出。
链表练习题
Q_M_X_D_D_的博客
09-16 489
链表 这里我记录了链表的各种操作的算法，在后面的习题中会涉及到这些算法的思路。 LeetCode206.反转链表 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 反序的算法之前记录过，可以就地反序，也可以使用栈反序，这里为了节...
C语言实现通用双向链表标准版.rar
08-12
“【20培训】C语言培训习题 01_廖鸿鹏”可能是一个相关的习题集，可能包含了对这个双向链表实现的练习和测试案例，帮助学习者加深对链表操作的理解和应用。 总的来说，这个资源为学习C语言、数据结构和操作系统提供...
c语言编程题之链表操作设计链表.zip
最新发布
03-30
在实际编程题中，可能需要设计一系列的函数来实现这些操作，如`createNode`（创建节点）、`insertAtHead`（在头部插入）、`insertAtTail`（在尾部插入）、`deleteNode`（删除节点）、`printList`（打印链表）等。...
考研数据结构分类讲解练习额外练习题.7z
08-25
本压缩包文件“考研数据结构分类讲解练习额外练习题.7z”提供了丰富的额外练习题，旨在帮助准备考研的学生深化对数据结构的理解并提高解题能力。 首先，我们要理解数据结构的基本概念。数据结构可以分为两大类：...
基础链表练习（附详细注释）
04-08
实现一个带头结点的字符串链表，每插入一个字符串，链表会对其进行按字典进行排序。 重复插入的字符串自动忽略。 通过索引号可以获取到对应位置上的字符串。 移除一个特定的元素 返回链表中存储的字符串个数
链表习题答案
10-30
是链表方面，在这说一下，链表学好很重要。
lianbiao.rar_数据结构作业_链表题
09-20
下面将详细探讨链表这一重要数据结构及其在实际编程中的应用。 链表是一种线性数据结构，与数组不同，它的元素并不存储在连续的内存位置。每个元素，也称为节点，包含两个部分：数据域，用于存储数据；指针域，用于...
二叉树的实现及其相关习题~
qq_57603004的博客
03-06 501
Java实现二叉树~
链表的练习
奋斗的龙猫的博客
09-13 396
文章目录回文链表重排链表排序的循环链表 回文链表 给定一个链表的 头节点 head ，请判断其是否为回文链表。 如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。 示例 1： 输入: head = [1,2,3,3,2,1] 输出: true 示例 2： 输入: head = [1,2] 输出: fasle 提示： 链表 L 的长度范围为 [1, 105] 0 <= node.val <= 9 进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 来源：力扣（L
链表练习题（一）
curelmn的博客
07-30 184
1.删除链表中等于给定值val的所有节点。 思路：遍历链表，查找到给定值节点，删除改节点，即使改节点的上一个节点指向下下一个节点。 class ListNode{ int val=0; ListNode next=null; public ListNode(){ } public ListNode(int val){ this.val=val; this.next=null; } public ListNode
编程题——关于链表
TNT_xixixi的博客
02-12 610
目录 从尾到头打印链表（剑指欧肥儿） 删除链表中重复的节点（剑指欧肥儿） 链表中环的入口结点（剑指欧肥儿） 两个链表的第一个公共结点（剑指欧肥儿） 合并两个排序的链表（剑指欧肥儿） 反转链表（剑指欧肥儿） 从尾到头打印链表（剑指欧肥儿） 题目描述：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 解题代码： class Solution...
链表类编程题
qq_43003252的博客
07-10 361
1.从尾到头打印链表 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 思路：(1)利用栈先入后出的特性完成; (2）第二就是存下来然后进行数组翻转。 （3）利用递归。 代码： //利用c++中自带的翻转函数reverse实现 class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { vector<int> value; Lis
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值