Java——LinkedList

最新推荐文章于 2024-09-08 23:27:05 发布
最新推荐文章于 2024-09-08 23:27:05 发布
阅读量888 收藏 4
点赞数 9
分类专栏： Java集合及数据结构 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yuan_o_/article/details/139603275
版权

1、链表

1.1 链表的概念及结构

链表在逻辑层面上是连续的，在物理层面上不一定是连续的

链表结构可分为，单向或双向、带头或不带头、循环或非循环，组合共计8种

重点：无头单向非循环链表、无头双向链表

1.2 模拟实现无头单向非循环链表

一个链表由若干节点组成，结合 内部类 知识，可将节点类定义在链表类中，成为内部类

public class MySingleLinkedList {

    static class ListNode {//该内部类中定义的是节点的属性
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;//链表的头节点，定义在MySingleLinkedList类中
    
}

下面以穷举的方式创建链表方便理解（真正创建链表并非如此）

//MySingleLinkedList类

    //该方法创建一个链表，头节点为node1，当该方法结束后，变量node1...都会销毁，只剩下头节点为head的链表
    public void createdList(){
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        this.head = node1;
    }

打印链表

//MySingleLinkedList 类

    public void display() {
        ListNode cur = head; //若直接使用head进行遍历打印，将只能打印一次，再次调用该函数，头节点就不在原来的位置了
        while(cur != null) { //注意！此处若写成 cur.next != null 则不会打印最后一个节点
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }

求链表长度：

    //遍历即可
    public int size() {
        ListNode cur = head;
        int count = 0;
        while(cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

头插法：

    public void addFirst(int data) {
        ListNode newNode = new ListNode(data);
        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.next != null 则不会打印最后一个节点
            cur = cur.next;
        }
        cur.next = newNode;
    }

在index位置插入

// IndexNotLegalException 异常类
public class IndexNotLegalException extends RuntimeException{
    public IndexNotLegalException() {

    }
    public IndexNotLegalException(String msg) {
        super(msg);
    }
}


// MySingleLinkedList 类
    public void addIndex(int index, int data) {
        //1、判断index合法性
        try{
            checkIndex(index);
        }catch(IndexNotLegalException e) {
            e.printStackTrace();
        }
        //2、index == 0 || index == size()
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        //3、找到index的前一个位置
        ListNode cur = findIndexSubOne(index);
        //4、进行连接
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
    }
    private void checkIndex(int index) throws IndexNotLegalException{
        if(index < 0 || index > size()) {
            throw new IndexNotLegalException("index不合法！");
        }
    }
    private ListNode findIndexSubOne(int index) {
        int count = 0;
        ListNode cur = head;
        while(count < index-1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

查找关键字key是否包含在链表中

    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null) {
            if(cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

删除第一次出现关键字key的节点

    public void remove(int key) {
        //判空
        if(head == null) {
            return;
        }
        //若头节点为key
        while(head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = head;
        //遍历找到值为key的节点
        while(cur.next != null) {
            if(cur.next.val == key) {
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
        System.out.println("没有找到要删除的数字！");
    }

删除所有值为key的节点

    public void removeAllKey(int key) {
        //判空
        if (this.head == null) {
            return;
        }
        //快慢指针
        ListNode prev = head;
        ListNode cur = head.next;
        while(cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
            }else {
                prev = cur;
            }
            cur = cur.next;
        }
        //处理头节点，当上述操作完成后，只剩下头节点没有判断
        //该方法优于一上来就判断头节点
        if(head.val == key) {
            head =head.next;
        }
    }

清空链表

    public void clear() {
        ListNode cur = head;
        while(cur != null) {
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }

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

public class MyLinkedList {
    static class ListNode {
        public int data;
        public ListNode prev;//前驱节点
        public ListNode next;//后继节点

        public ListNode(int data){
            this.data = data;
        }
    }

    public ListNode head;//头节点
    public ListNode last;//尾节点

    //得到单链表的长度
    public int size(){
        int count = 0;
        ListNode cur = head;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
    public void display(){
        ListNode cur = head;
        while(cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.data == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    //头插法
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = last = node;
        }else {
            head.prev = node;
            node.next = head;
            head = node;
        }
    }
    //尾插法
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = last = node;
        }else {
            last.next = node;
            node.prev = last;
            last = node;
        }
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        try{
            checkIndex(index);
        }catch(IndexIllegalException e) {
            e.printStackTrace();
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }
    private ListNode findIndex(int index) {
        ListNode cur = head;
        while(index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }
    private void checkIndex(int index) throws IndexIllegalException{
        if(index < 0 || index > size()) {
            throw new IndexIllegalException("双向链表index不合法！");
        }
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.data == key) {
                if(cur == head) {
                    head = head.next;
                    if(head != null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else if(cur == last) {
                    cur.prev.next = null;
                    last = cur.prev;
                }else {
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                }
                return;

            }
            cur = cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.data == key) {
                if(cur == head) {
                    head = head.next;
                    if(head != null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else if(cur == last) {
                    cur.prev.next = null;
                    last = cur.prev;
                }else {
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                }
            }
            cur = cur.next;
        }
    }

    public void clear(){
        ListNode cur = head.next;
        while(cur != null) {
            cur = head.next;
            head.prev = null;
            head.next = null;
            head = cur;
        }
        head = last = null;
    }
}

链表遍历方式：

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        //直接sout打印
        System.out.println(list);
        System.out.println("======");

        //foreatch循环打印
        for(Integer x : list) {
            System.out.print(x + " ");
        }
        System.out.println();
        System.out.println("======");

        //for循环打印
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        System.out.println("======");

        //Iterator打印
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
        System.out.println("======");

        //ListIterator可以倒着打印
        ListIterator<Integer> it3 = list.listIterator(list.size());
        while(it3.hasPrevious()) {
            System.out.print(it3.previous() + " ");
        }
    }

运行结果：

2、ArrayList 和 LinkedList 的区别

不同点ArrayListLinkedList
存储空间上逻辑&物理均连续逻辑上连续，物理上不一定连续
随机访问支持，时间复杂度为O(1)不支持，时间复杂度为O(N)
头插需要搬运元素，O(N)只需修改引用的指向，O(1)
插入空间不够时需要扩容没有容量概念
应用场景元素高效存储+频繁访问频繁在任意位置插入删除操作

Yuan_o_
关注
专栏目录
java 数据结构 遍历链表程序
02-07
java 数据结构 遍历链表程序 有研究或探讨的请加群:37424970 或联系本人MSN或邮箱:zhuseahui@yahoo.com.cn
《Java基础-集合：深入了解Java中LinkedList类的使用及实用技巧（最全篇）》
大大大钢琴
07-31 997
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.，它和ArrayList一样实现了List接口，但是她执行插入和删除操作时比ArrayList更加高效，因为她是基于链表的，但同时也决定了她在随机访问方面要比ArrayList弱一点。
Java实现链表
最新发布
2401_84436253的博客
09-08 717
之后就是插入和删除的操作，插入的操作我们已经了解了，删除只需要跳过我们需要删除的结点的地址值就行了也就是我们需要得到需要删除结点的前一个结点，将前一个结点的next指向需要删除的next这样就删除了指向我们需要删除的结点的地址值了。若是先将 head的next直接指向newNode那我们将无法找到1号结点的地址值了，因为你的第一步操作已经将含有1号结点的地址值的重新赋值了，了解了这个之后就方便了解链表的其他操作了。链表是一种很常见的数据结构，相比与顺序表它们两种结构都是存储数据的。
Java---链表的遍历
qq_45277758的博客
03-05 6966
创建一个链表 //创建一个链表 public static Node createList(){ //创建四个Node实例，再定义四个引用来分别指向这四个实例 //随着方法的结束，a,b,c,d也随之销毁 Node a=new Node(1); Node b=new Node(2); Node c=new Node(3); Node d=new Node(4); //给引用进行赋值 /.
Java中如何对LinkedList进行遍历呢？
qq_25073223的博客
08-19 415
Java中对LinkedList进行遍历的方法分享
java LinkedList三种遍历方法
m0_53188792的博客
03-20 1561
集合遍历三种方法
详解Java 集合系列（三）—— LinkedList
08-26
Java 集合系列——LinkedList Java 集合系列中的 LinkedList 是一种可以在任何位置进行高效地插入和删除操作的有序序列。它的最基本存储结构是一个节点：每个节点将存储对象，以及前后节点的引用。结构图中，我们...
java用linkedlist编写学生类_Java基础之：List——LinkedList
weixin_36180068的博客
02-24 551
Java基础之：List——LinkedListLinkedList简单介绍LinkedList实现了双向链表(数据结构)和双端队列特点。实现了List接口，可以添加任意元素(即可以重复和null)，线程不安全。LinkedList底层实现分析LinkedList底层维护了一个双向链表LinkedList中维护了两个属性first和last，分别指向首节点和尾节点每个节点(数据结构中将节点都称作N...
Java集合容器——LinkedList
Koliday的学习之路
02-18 321
一，LinkedList特点： 1. LinkedList具有List的有序性和可重复性 2.LinkedList底层使用双向链表，也是一个双向队列，因此查询速度慢（需要遍历），不支持随机访问，但是增删元素方便 3. 不要采用随机访问的方式去遍历LinkedList，因为每次get操作都会再次遍历，时间复杂度较高 二，LinkedList源码分析： 类定义： public class...
java集合—— LinkedList(双链表)的理解与用法
haha_7的博客
03-13 1880
LinkedList介绍 知识点 LinkedList 是以链表实现的，插入、删除时只需要改变前后两个节点指针指向。 LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用。 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 的成员变量只有三个：头节点 first、尾节点 last、容量 size LinkedList 实现 List 接口，能对它进行队列操作。 Lin
Java集合容器复习2————LinkedList和Queue
weixin_43192732的博客
03-13 319
LinkedList LinkedList 的简介 LinkedList是基于链表实现的，LinkedList是一种双向链表，双向链表我认为有两点含义： 1、链表中任意一个存储单元都可以通过向前或者向后寻址的方式获取到其前一个存储单元和其后一个存储单元 2、链表的尾节点的后一个节点是链表的头结点，链表的头结点的前一个节点是链表的尾节点 LinkedList的基本存储单元，它是LinkedList...
Java链表创建及遍历方法
KK的博客
05-31 4541
在当前结构中添加构造方法，便于对链表进行初始化。 构建链表 构建链表的方法与C相似，其基本思想是： 遍历链表 遍历链表方法其实很简单，就是从头结点出发开始遍历，当指向的结点为空时停止遍历，说明此时链表已经遍历完成。
Java 【数据结构】 LinkedList【神装】
2302_79806056的博客
04-10 1561
说明LinkedList是Java中提供的双向链表实现的数据结构。它实现了List接口，因此可以像操作普通的列表一样对其进行操作，同时也支持队列和栈的操作。与ArrayList相比，LinkedList在插入和删除元素时具有更好的性能，因为它不需要移动其他元素。但是在访问特定位置的元素时，LinkedList的性能较差，因为需要从头或尾开始遍历链表。总的来说，LinkedList适合频繁进行插入和删除操作的场景。注意LinkedList实现了List接口LinkedList。
Java-集合(LinkedList类)
Ego_Ekko的博客
08-29 865
1）LinkedList底层实现了双向链表和双端队列特点；2）可以添加任意元素（元素可重复），包括null；3）线程不安全，没有实现同步。
java模拟---遍历链表
掘客DIGGKR
06-06 732
public class TestList { private static final int len = 10; public static void main(String[] args) { Student[] array = new Student[len]; Student stu = new Student(); stu.setName("name " + 0);
java linklist 遍历_使用Java中的迭代器遍历LinkedList
weixin_35304361的博客
02-16 1208
迭代器可用于遍历LinkedList。如果LinkedList中有更多元素，则hasNext()方法返回true，否则返回false。next()方法返回LinkedList中的下一个元素，如果没有下一个元素，则抛出异常NoSuchElementException。演示该程序的程序如下。示例importjava.util.LinkedList;importjava.util.Iterator;...
Java小白入门200例106之遍历ArrayList的几种方式
编程界明世隐的博客
10-13 677
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 引言 很多Java初学者问我，新手明明很用心、很努力学习的Java知识，转头又忘记了，很让人犯愁，小白如何能够快速成长、成为大牛呢？ 其实要成为大神的技巧只有一个：“多学多练”，于是明哥就整理了比较典型的练习实例，通过练习能够快速提升编码技巧和熟练度，让你在成为大
链表的插入、修改、删除、遍历--java
xwonderful的博客
09-06 1402
package List; public class ListNode { private class Node { private Object obj; private Node next = null; Node(Object obj){ this.obj = obj;
JAVA LinkedList与ArrayList对比：性能与应用场景详解
本文主要讨论了两种常用的List实现类——ArrayList和LinkedList，以及它们各自的特性和使用场景。 首先，List接口是一个抽象概念，它继承自Collection接口，提供了对有序集合的统一访问方式。AbstractList是List...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值