LinkedList&链表

最新推荐文章于 2024-05-20 22:31:31 发布
最新推荐文章于 2024-05-20 22:31:31 发布
阅读量33 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72536301/article/details/130024306
版权

一. 链表

1.1 链表的概念

链表也是线性表，是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的

 

 

 可以看到，链表是在堆上申请的，各对象的地址不一定是连续的

1.2 链表的结构

链表有三种分类：单向/双向，有头/无头，循环/非循环

组合起来一共有八种链表

1.单向/双向

 2.有头/无头

 3.循环/非循环

 本篇文章的主角是无头单向非循环链表/无头双向循环链表

1.3 无头单向非循环链表的实现

 下面模拟实现一下无头单向非循环链表

单向链表需要有一个头节点，保存第一个对象的地址

public class SingleList {

    //定义结点为链表的内部类
    class ListNode {

        int val;
        ListNode next;
        public ListNode(int data) {
            this.val = data;
        }
    }
    //保存第一个结点，否则无法找到该链表
    ListNode head;
    //头插法
    public void addFirst(int data){
        ListNode newnode=new ListNode(data);
        if(head==null) {
            head=newnode;
            return;
        }
        newnode.next=head;
        head=newnode;
    }
    //尾插法
    public void addLast(int data){
        ListNode newnode=new ListNode(data);
        if(head==null) {
            head=newnode;
            return;
        }
        ListNode cur=head;
        while(cur.next!=null) {
            cur=cur.next;
        }
        cur.next=newnode;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        if(index>this.size()||index<0) {
            throw new IllegalIndex("插入下标不合法");
        }
        if(index==0) {
            addFirst(data);
            return;
        }
        ListNode cur=head;
        index--;
        while(index>0) {
            cur=cur.next;
        }
        cur.next=new ListNode(data);
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur=head;
        while(cur!=null) {
            if(cur.val==key) { //如果要判断的类型为引用类型，要使用equals
                return true;
            }
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
        if(head==null) return;
        if(head.val==key) {
            head=head.next;
            return;
        }
        ListNode cur=head;
        while(cur.next!=null) {
            if(cur.next.val==key) {
                cur.next=cur.next.next;
                break;
            }
            cur=cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        if(head==null) return;
        while(head!=null&&head.val==key) {
            head=head.next;
        }
        ListNode prev=head,cur=head.next;
        while(cur!=null) {
            if(cur.val==key) {
                prev.next=cur.next;
                cur=prev.next;
            } else {
                prev=cur;
                cur=prev.next;
            }
        }
    }
    //得到单链表的长度
    public int size(){
        ListNode cur=head;
        int num=0;
        while(cur!=null) {
            num++;
            cur=cur.next;
        }
        return num;
    }
    public void clear() {
        head=null;
    }
    public void display() {
        ListNode cur=head;
        while(cur!=null) {
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
        System.out.println();
    }
}

//下标不合法异常的定义
public class IllegalIndex extends RuntimeException{
    public IllegalIndex() {
    }

    public IllegalIndex(String message) {
        super(message);
    }
}

1.4 无头双向非循环链表的实现

下面模拟实现无头双向非循环链表

双向链表需要有头结点和尾结点，方便进行双向遍历

public class MyLinkedList {
       class LinkNode {
           int val;
           LinkNode next;
           LinkNode prev;

           public LinkNode(int val) {
               this.val = val;
           }
       }
       LinkNode head;
       LinkNode last;
        //头插法
        public void addFirst(int data){
            LinkNode node=new LinkNode(data);
            if(head==null) {
                head=last=node;
                return;
            }
            node.next=head;
            head.prev=node;
            head=node;
        }
        //尾插法
        public void addLast(int data){
            LinkNode node=new LinkNode(data);
            if(last==null) {
                head=last=node;
                return;
            }
            last.next=node;
            node.prev=last;
            last=node;
        }
        //任意位置插入,第一个数据节点为0号下标
        public void addIndex(int index,int data){
            if(index<0) {
                throw new IllegalIndex("插入下标不合法");
            }
            if(index==0) {
                addFirst(data);
                return;
            }
            LinkNode prev=head;
            index--;
            while(index>0) {
                if(prev==null) {
                    throw new IllegalIndex("插入下标不合法");
                }
                prev=prev.next;
                index--;
            }
            if(prev==null) {
                throw new IllegalIndex("插入下标不合法");
            }
            LinkNode node=new LinkNode(data);
            prev.next.prev=node;
            node.next=prev.next;
            node.prev=prev;
            prev.next=node;
        }
        //查找是否包含关键字key是否在单链表当中
        public boolean contains(int key){
            LinkNode cur=head;
            while(cur!=null) {
                if(cur.val==key) {
                    return true;
                }
                cur=cur.next;
            }
            return false;
        }
        //删除第一次出现关键字为key的节点
        public void remove(int key){
            LinkNode cur=head;
            while(cur!=null) {
                if(cur.val==key) {
                    if(cur==head) {
                        head=head.next;
                        head.prev=null;
                        if(head==null)
                            last=null;
                        return;
                    }
                    if(cur==last) {
                        last=last.prev;
                        last.next=null;
                        if(last==null)
                            head=null;
                        return;
                    }
                    LinkNode prev=cur.prev;
                    LinkNode next=cur.next;
                    prev.next=next;
                    next.prev=prev;
                    return;
                }
                cur=cur.next;
            }
        }
        //删除所有值为key的节点
        public void removeAllKey(int key){
            LinkNode cur=head;
            while(cur!=null) {
                if(cur.val==key) {
                    if(cur==head) {
                        head=head.next;
                        if(head==null)
                            last=null;
                        return;
                    }
                    if(cur==last) {
                        last=last.prev;
                        if(last==null)
                            head=null;
                        return;
                    }
                    LinkNode prev=cur.prev;
                    LinkNode next=cur.next;
                    prev.next=next;
                    next.prev=prev;
                }
                cur=cur.next;
            }
        }
        //得到链表的长度
        public int size(){
            LinkNode cur=head;
            int len=0;
            while(cur!=null){
                cur=cur.next;
                len++;
            }
            return len;
        }
        public void display(){
            LinkNode cur=head;
            while(cur!=null) {
                System.out.print(cur.val+" ");
                cur=cur.next;
            }
            System.out.println();
        }
        public void clear(){
            head=last=null;
        }

}

上面clear的实现中使用了比较粗暴的解决方法---直接将头结点和尾结点置空，实际上源码是十分温柔的，分别遍历了每个对象并一一置空

Tip：

下面验证下本博主clear方法究竟实现了没有

你以为我只是简单地打印，当然不是！

 在cmd上输入下面的命令，会在d盘上的cookie.txt文件里生成实例对象

这是未使用clear方法时的实例

 

下面执行一下clear方法，在cookie.txt文件中再次查找LinkNode

 

二. LinkedList

LinkedList 的底层是双向链表结构 ，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高
下图为LinkedList的结构框架

 

 从这个框架中可以得出：

1. LinkedList没有实现RandomAccess接口，因此不支持随机访问

2. LinkedList实现了List接口，因此LinkedList也是线性表

3. LinkedList实现了Cloneable接口，因此支持克隆

4. LinkedList实现了Seriallizable接口，因此支持序列化

2.1 LinkedList的使用

1.LinkedList的构造

与ArrayList相同，LinkedList也支持一个实现了Collection接口的对象帮助构造

public static void main(String[] args) {
        //创造一个ArrayList对象
        ArrayList<Integer> array=new ArrayList<>();
        array.add(1);
        array.add(2);
        array.add(3);

        //帮助初始化的对象其泛型参数必须和LinkedList一致
        LinkedList<Integer> list=new LinkedList<>(array);
        System.out.println(list);
    }

输出结果

 

 2. 下面列举LinkedList的常用方法

方法功能
boolean add (E e)
尾插e
void add (int index, E element)
将 e 插入到 index 位置
boolean addAll (Collection<? extends E> c)
尾插 c 中的元素
E remove (int index)
删除 index 位置元素
boolean remove (Object o)
删除遇到的第一个 o
E get (int index)
获取下标 index 位置元素
E set (int index, E element)
将下标 index 位置元素设置为 element
void clear ()
清空
boolean contains (Object o)
判断 o 是否在线性表中
int indexOf (Object o)
返回O第一次出现的下标
int lastIndexOf (Object o)
返回O最后出现的下标
List<E> subList (int fromIndex, int toIndex)
截取部分list

 

 3. LinkedList的遍历

因为LinkedList不支持随机访问，LinkedList没有for+下标遍历的用法

1. for-each

public static void main(String[] args) {

        LinkedList<Integer> link=new LinkedList<>();
        for(int i=1;i<=10;i++)
            link.add(i);

        for(int e:link) {//增强for循环
            System.out.print(e+" ");
        }
    }

2. 使用迭代器

迭代器不仅可以实现正序访问，因为双向链表的底层结构，使用迭代器也可以进行反向访问

public static void main(String[] args) {

        LinkedList<Integer> link=new LinkedList<>();
        //给link添加元素
        for(int i=1;i<=10;i++)
            link.add(i);
      
        //使用迭代器正向访问
        ListIterator<Integer> it= link.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
       
        //使用迭代器反向访问
        it= link.listIterator(link.size());//传入下标应为链表大小
        while(it.hasPrevious()) {
            System.out.print(it.previous()+" ");
        }

    }

输出结果

 为什么要传入链表大小呢？

按照正向迭代器的逻辑逻辑传入的应该是是最后一个元素的下标，即size-1

一起来看看LinkedList的迭代器吧

 

 下面是反向迭代器

 总结：

使用正向迭代器时，是包含下标为index的元素的迭代

使用反向迭代器时，不包含下标为Index的元素

下图验证

public static void main(String[] args) {

        LinkedList<Integer> link=new LinkedList<>();
        for(int i=1;i<=10;i++)
            link.add(i);

        ListIterator<Integer> it= link.listIterator(0);//传入第一个元素的下标
        
        while(it.hasNext()){
            System.out.print(it.next()+" ");
            //it.remove()
        }

        System.out.println();
        System.out.println("******************");

        it= link.listIterator(link.size()-1);//传入倒数第一个元素的下标
        
        while(it.hasPrevious()) {
            System.out.print(it.previous()+" ");
        }

    }

第一个输出结果包含第一个元素，第二个输出结果不包含最后一个元素

 

三. ArrayList  VS  LinkedList

比较项ArrayListLinkedList
增添只适合尾插，其他的插入需要移动元素不需要移动元素，插入时需要遍历
查找可以随机查找需要遍历链表
删除只适合删除末尾元素，其他删除需要移动元素不需要移动其他元素，需要遍历链表
物理实现物理空间连续，底层是数组物理空间不连续，底层是双向链表

不 会敲代码
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LinkedList:链表
07-03
链表Shashank Shekhar 的链接列表实现
LinkedList:链表算法
04-13
链表 链表算法 链表算法的实现，该算法从stdin读取用户命令并根据用户指令命令在链表上运行特定功能，例如：PUT n，GET n，LIST，FIRST，LAST，SORT，CLEAR，REMOVE n，EXIT，其中： PUT n-将一个整数n插入到链表中...
LinkedList与链表
如风暖阳的博客
07-05 451
LinkedList与链表
java中LinkedList与链表
m0_62055442的博客
10-01 451
java中LinkedList与链表
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2478
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
LinkedList和链表
2301_78804510的博客
04-21 1094
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
java学习之LinkedList（链表）
qq_45754762的博客
05-03 1601
java LinkedList是java中的链表结构，具有高效的增加和删除元素功能。
LinkedList 双向链表
weixin_69484761的博客
10-08 54
Java——LinkedList与链表介绍
华墨1024的博客
11-07 693
本文将对链表和LinkedList进行简要介绍
LinkedList 和 链表
TheDevice的博客
04-18 543
LinkedList 和 链表 我们之前已经学习了ArrayList，我们知道ArrayList是通过数组来储存元素的。所以，在我们使用他来插入删除链表的时候，时间复杂度达到了O（n），效率很低，所以ArrayList不适合于插入删除操作，因此，java又引入了一种新型的结构-------LinledList。 LinkedList常用的方法 ArrayList和LinkedList的区别
LinkedList-双向链表
weixin_43681666的博客
11-19 1290
LinkedList-双向链表 《Hash Map源码基于jdk_8》 1. 类的继承关系 双向链表实现了List和Deque(双向队列)接口 2. 变量及其含义 变量名 默认值 含义 其他补充 size 0 地球人都知道 first 头节点 last 尾节点 3.构造函数 分为无参构造和有参构造，无参构造啥也不做。有参构造以Collection为参数，并初始化。 List<String> noArgslinkedList = new Link
【数据结构】LinkedList与双向链表
qq_61903414的博客
12-20 1530
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
linkedlist_链表_
10-02
单双链表的创建，节点的添加与删除，链表逆序，链表遍历。
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
二叉树专题（有关二叉树的相关学习）
aaa114514aaaa的博客
05-14 1590
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 741
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 734
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 406
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
数据结构之链表
qq_63448996的博客
05-19 457
2.然后，从第二个节点开始，依次将每个节点插入到头节点之后。这样，原来的第二个节点就变成了新的头节点，原来的第三个节点就变成了新的第二个节点，
Linkedlist双向链表
03-29
Linkedlist双向链表是一种数据结构，它由一系列节点组成，每个节点包含一个指向前一个节点和后一个节点的指针。在双向链表中，可以从任何一个节点开始向前或向后遍历整个链表。 与单向链表不同，双向链表可以在任何...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不 会敲代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值