链表及相关练习

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量36 收藏
点赞数
文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44936836/article/details/132237484
版权

一.自己实现一个简单的单链表

public class MySingleList {
    static class Node{
        public int val;//代表节点的数据
        public Node next;//存储下一个节点的地址

        public Node(int val) {
            this.val = val;
        }
    }
    public Node head;//代表当前链表的头节点

    //创建链表
    public void createLink(){
        Node node1=new Node(12);
        Node node2=new Node(12);
        Node node3=new Node(12);
        Node node4=new Node(12);
        Node node5=new Node(12);
        node1.next=node2;
        node2.next=node3;
        node3.next=node4;
        node4.next=node5;
        head=node1;
    }

    //遍历链表
    public void display(){
        Node cur=head;
        while(cur!=null){
            System.out.print(cur.val+"  ");
            cur=cur.next;
        }
    }

    //查找单链表中是否包含关键字key
    public boolean contains(int key){
        Node cur=head;
        while(cur!=null){
            //如果是引用类型要重写equals
            if(cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }

    //得到链表的长度
    public int size(){
        int count=0;
        Node cur=head;
        while(cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }

    //头插法，O（1）
    public void addFirst(int val){
        Node node=new Node(val);
        node.next=head;
        head=node;
    }

    //尾插法，O（n）
    public void addLast(int val){
        Node node=new Node(val);
        Node cur=head;
        //注意判断head==null的情况，否则会空指针异常
        if(cur==null){
            head=node;
            return;
        }
        while(cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }

    //任意位置插入节点
    public void addIndex(int index,int val){
        checkIndex(index);
        if(index==0){
            addFirst(val);
            return;
        }
        if(index==size()){
            addLast(val);
            return;
        }
        Node node=new Node(val);
        Node cur=findIndexSubOne(index);
        node.next=cur.next;
        cur.next=node;
    }
    //找出插入位置的前一个节点
    private Node findIndexSubOne(int index){
        Node cur=head;
        while(index-1!=0){
            cur=cur.next;
        }
        return cur;
    }
    //检查index位置合法性
    private void checkIndex(int index) {
        if(index<0||index>size()){
            throw new ListIndexOutOfException("index位置不合法");
        }
    }
    //查找key节点的前一个节点
    private Node searchPrev(int key){
        if(head==null){
            return null;
        }
        Node cur=head;
        while(cur.next!=null){
            if(cur.next.val==key){
                return cur;
            }
            cur=cur.next;
        }
        return null;//没有需要删除的节点
    }
    //删除第一个出现的关键字为key的节点
    public void remove(int key){
        if(head==null){
            return;
        }
        if(head.val==key){
            head=head.next;
            return;
        }
        Node cur=searchPrev(key);
        if(cur==null){
            return;
        }
        cur.next=cur.next.next;
    }

    //删除所有值为key的节点
    public void removeAll(int key){
        if(head==null){
            return;
        }
        while (head!=null&&head.val==key){
            head=head.next;
        }
        Node cur=head;
        while(cur!=null&&cur.next!=null){
            if(cur.next.val==key){
                cur.next=cur.next.next;
            }else{
                cur=cur.next;
            }
        }
    }

    //清空链表
    public void clear(){
        head=null;
    }

}

二.相关题目练习
1.删除链表中所有指定值的节点（https://leetcode.cn/problems/remove-linked-list-elements/）。
实例：在这里插入图片描述
思路：
在这里插入图片描述

实现：

 public ListNode removeElements(ListNode head, int val) {
        if(head==null){
            return null;
        }
        ListNode cur=head.next;
        ListNode prev=head;
        while(cur!=null){
            if(cur.val==val){
                prev.next=cur.next;
                cur=cur.next;
            }else{
                prev=cur;
                cur=cur.next;
            }
        }
        if(head.val==val){
            head=head.next;
        }
        return head;
    }

2.反转一个单链表（https://leetcode.cn/problems/reverse-linked-list/）
例子：
在这里插入图片描述
思路：
实现：

public ListNode reverseList(ListNode head) {
        if(head==null){
            return null;
        }
        if(head.next==null){
            return head;
        }
        ListNode cur=head.next;
        head.next=null;
        while(cur!=null){
            ListNode curNext=cur.next;
            cur.next=head;
            head=cur;
            cur=curNext;
        }
        return head;
    }

3.返回链表的中间节点（https://leetcode.cn/problems/middle-of-the-linked-list/）
例子：
在这里插入图片描述

思路：
在这里插入图片描述
实现：

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

4.返回倒数第k个节点（https://www.nowcoder.com/practice/886370fe658f41b498d40fb34ae76ff9?tpId=196&tqId=37100&rp=1&ru=/exam/oj&qru=/exam/oj&sourceUrl=%2Fexam%2Foj%3Fpage%3D1%26pageSize%3D50%26search%3D%25E9%2593%25BE%25E8%25A1%25A8%25E4%25B8%25AD%25E5%2580%2592%25E6%2595%25B0%26tab%3D%25E7%25AE%2597%25E6%25B3%2595%25E7%25AF%2587%26topicId%3D196&difficulty=undefined&judgeStatus=undefined&tags=&title=%E9%93%BE%E8%A1%A8%E4%B8%AD%E5%80%92%E6%95%B0）
例子：
在这里插入图片描述
思路：
在这里插入图片描述
实现：

public ListNode FindKthToTail (ListNode pHead, int k) {
        if(k<=0||pHead==null){
            return null;
        }
        ListNode fast=pHead;
        ListNode slow=pHead;
        //fast走k-1步
        while(k-1!=0){
            fast=fast.next;
            //fast==null时说明k的值要大于链表的长度
            if(fast==null){
                return null;
            }
            k--;
        }
        while(fast.next!=null){
            fast=fast.next;
            slow=slow.next;
        }
        return slow;
    }

5.合并两个有序链表（https://leetcode.cn/problems/merge-two-sorted-lists/）
例子：
在这里插入图片描述

思路：
在这里插入图片描述
实现：

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1==null&&list2==null){
            return null;
        }
        ListNode newHead=new ListNode();
        ListNode temp=newHead;
        while(list1!=null&&list2!=null){
            if(list1.val<list2.val){
                temp.next=list1;
                list1=list1.next;
                temp=temp.next;
            }else{
                temp.next=list2;
                list2=list2.next;
                temp=temp.next;
            }
        }
        if(list1==null){
            temp.next=list2;
        }
        if(list2==null){
            temp.next=list1;
        }
        return newHead.next;
    }

6.以一个基准值分割一个链表（https://www.nowcoder.com/questionTerminal/0e27e0b064de4eacac178676ef9c9d70）
思路：
在这里插入图片描述

实现：

public ListNode partition(ListNode pHead, int x) {
        ListNode bs=null;
        ListNode be=null;
        ListNode as=null;
        ListNode ae=null;
        ListNode cur=pHead;
        while(cur!=null){
            if(cur.val<x){
                if(bs==null){
                    bs=cur;
                    be=cur;
                }else{
                    be.next=cur;
                    be=be.next;
                }
            }else{
                if(as==null){
                    as=cur;
                    ae=cur;
                }else{
                    ae.next=cur;
                    ae=ae.next;
                }
            }
             cur=cur.next;
        }
        //第一段为空，返回第二段
        if(bs==null){
            return as;
        }
        //第二段为空，返回第一段
        if(as==null){
            return bs;
        }
        be.next=as;
        ae.next=null;
        return bs;
    }

7.链表的回文结构（https://leetcode.cn/problems/palindrome-linked-list/submissions/）
例子：
在这里插入图片描述
思路：
在这里插入图片描述
实现：

 public boolean isPalindrome(ListNode head) {
        if(head==null){
            return true;
        }
        if(head.next==null){
            return true;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        ListNode cur=slow.next;
        ListNode prev=slow;
        while(cur!=null){
            ListNode curNext=cur.next;
            cur.next=prev;
            prev=cur;
            cur=curNext;
        }
        while(head!=prev){
            if(head.val!=prev.val){
                return false;
            }
            //偶数的情况
            if(head.next==slow){
                return true;
            }
            head=head.next;
            prev=prev.next;
        }
        return true;
    }

8.找出链表的公共节点(https://leetcode.cn/problems/intersection-of-two-linked-lists/)
思路：
在这里插入图片描述

实现：

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lengthA=0;
        int lengthB=0;
        ListNode pA=headA;
        ListNode pB=headB;
        while(pA!=null){
            lengthA++;
            pA=pA.next;
        }
        while(pB!=null){
            lengthB++;
            pB=pB.next;
        }
        //确保pA是长链表，len>0
        int len=lengthA-lengthB;
        pA=headA;
        pB=headB;
        if(len<0){
            pA=headB;
            pB=headA;
            len=-len;
        }
        while(len!=0){
            pA=pA.next;
            len--;
        }
        while(pA!=pB){
            pA=pA.next;
            pB=pB.next;
        }
        return pA;
    }

9.判断链表是否有环（https://leetcode.cn/problems/linked-list-cycle/submissions/）
思路：快慢指针,slow每次走一步，fast每次走二步，slow==fasst说明有环，否则没环
实现：

 public boolean hasCycle(ListNode head) {
        if(head==null){
            return false;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                return true;
            }
        }
        return false;
    }

10.返回链表入环的第一个节点（https://leetcode.cn/problems/linked-list-cycle-ii/）
思路：相遇点与入口点的距离和起始点与入口点的距离相等
在这里插入图片描述

实现：

   public ListNode detectCycle(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                break;
            }
        }
        if(fast==null||fast.next==null){
            return null;
        }
        while(fast!=head){
            fast=fast.next;
            head=head.next;
        }
        return fast;
    }

三.模拟一个简单的LinkedList

public class MyLinkedList {
    static class ListNode{
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode last ;
    //头插,O(1)
    public void firstAdd(int val){
        ListNode node=new ListNode(val);
        if(head==null){
            head=node;
            last = node;
            return;
        }
        node.next=head;
        head.prev=node;
        head=node;
    }
    //尾插,O(1)
    public void lastAdd(int val){
        ListNode node=new ListNode(val);
        if(head==null){
            head=node;
            last=node;
            return;
        }
        last.next=node;
        node.prev=last;
        last=node;
    }
    //任意位置插入
    public void addIndex(int index,int val){
        if(index<0||index>size()){
            return;
        }
        if(index==0){
            firstAdd(val);
            return;
        }
        if (index==size()){
            lastAdd(val);
            return;
        }
        ListNode node =new ListNode(val);
        ListNode cur=head;
        while(index!=0){
            cur=cur.next;
            index--;
        }
        node.next=cur;
        node.prev=cur.prev;
        cur.prev.next=node;
        cur.prev=node;
    }
    //删除链表中值为key的节点
    public void remove(int key){
        ListNode cur=head;
        while(cur!=null){
            if(cur.val==key){
                if(cur==head){
                    head=head.next;
                    if(head!=null){
                        head.prev=null;
                    }
                    return;
                }
                if(cur==last){
                    last=last.prev;
                    last.next=null;
                    return;
                }
                cur.prev.next=cur.next;
                cur.next.prev=cur.prev;
                return;
            }else{
                cur=cur.next;
            }
        }
    }
    //删除链表中所有值为key的节点
    public void removeAll(int key){
        ListNode cur=head;
        while(cur!=null){
            if(cur.val==key){
                if(cur==head){
                    head=head.next;
                    if(head!=null){
                        head.prev=null;
                    }
                }else{
                    cur.prev.next=cur.next;
                    if(cur.next!=null){
                        cur.next.prev=cur.prev;
                    }else{
                        last=last.prev;
                    }
                }
            }
                cur=cur.next;
        }
    }
    //打印双向链表
    public void display(){
        ListNode cur=head;
        while(cur!=null){
            System.out.print(cur.val+"  ");
            cur=cur.next;
        }
    }
    //链表长度
    public int size(){
        int len=0;
        ListNode cur=head;
        while(cur!=null){
            len++;
            cur=cur.next;
        }
        return len;
    }
    //链表是否包含key
    public boolean contains(int key){
        ListNode cur=head;
        while(cur!=null){
            if(cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }
    //链表置空
    public void clear(){
        ListNode cur=head;
        while (cur!=null){
            ListNode curNext=cur.next;
            cur.prev=null;
            cur.next=null;
            cur=curNext;
        }
        head=null;
        last=null;
    }
}
不同点ArrayListLinkedList
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O（1）不支持O（n）
头插需要移动元素，O（n）只需要修改引用的指向，O（1）
插入空间不够需要扩容没有容量的概念
引用场景元素高效存储+频繁访问任意位置插入和删除元素
qq_44936836
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表相关练习.c
01-31
链表相关练习.c
环形链表相关的练习
melonyzzZ的博客
03-10 824
详解三道环形链表相关的练习。
删除链表元素相关的练习
melonyzzZ的博客
03-06 765
详解四道删除链表元素相关的练习。
链表知识及编程练习总结
热门推荐
张彦峰的博客
10-24 1万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
C语言之链表练习题
weixin_46305053的博客
12-06 3344
本关需要你设计一个程序，实现单链表的逆置。单链表的逆置分为两种方法：头插法和就地逆置法，这两种方法虽然都能够达到逆置的效果，但还是有着不小的差别。头插法逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。就地逆置法先假定有一个函数，可以将以为头结点的单链表逆序，并返回新的头结点。利用这个函数对问题进行求解：将链表分为当前表头结点和其余部分，递归的过程就是，先将表头结点从链表中拆出来，然后对其余部
链表介绍及题目练习
qq_41074616的博客
09-18 193
链表介绍及题目练习 一、链表介绍 链表实际上是线性表的链式存储结构，与数组不同的是，它是一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的，且链表的长度不是固定的，链表数据的这一特点使其可以非常方便地实现节点的插入和删除操作。 链表的每个元素称为一个节点，每个节点都可以存储在内存中的不同位置，为了表示每个元素与后继元素的逻辑关系，以便构成“一个节点链着一个节点”的链式存储结构，除了存储元素本身的信息外，还要存储其直接后继信息，因此，每个节点都包含两部分，第一部分称为链表的数据域，用于存储元素本身
链表应用练习
01-10
链表的一些练习，简单实用，通俗易懂，大概就是这样
16种链表的练习
08-17
16种链表的练习 1.c 有头 无序 不循环 单向 2.c 有头 有序 不循环 单向 3.c 无头 无序 不循环 单向 4.c 无头 有序 不循环 单向 5.c 有头 无序 循环 单向 6.c 有头 有序 循环 单向 7.c 无头 无序 循环 单向 ...
链表源码，练习文件
11-29
支持VS2015，非常好的学习资源。学习链表很有用。亲测可用。C语言
Java算法练习-链表的分化练习题
10-07
java
jar包增量更新分析
junlaiyan的专栏
05-16 263
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 679
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 622
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 914
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 906
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1024
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 253
java导出excel动态加载多sheet多复杂表头
K - 双向链表练习题
03-25
A：好的，下面是K - 双向链表练习题的解答。 题目描述： 设计一个数据结构，要求实现双向链表的基本操作：插入、删除、反转等，并实现一个方法向链表中添加一个元素。同时，该数据结构需要支持以下操作： 1. get...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值