LinkedList与链表

最新推荐文章于 2024-05-23 17:45:07 发布
最新推荐文章于 2024-05-23 17:45:07 发布
阅读量320 收藏
点赞数 1
分类专栏： JAVA数据结构 笔记 文章标签： java 开发语言 后端 数据结构 idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49266836/article/details/123586834
版权

链表

链表的概念及结构

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TUdImA8F-1647616558482)(D:\Typora笔记\图片\image-20220313165113953.png)]

注意：

​ 1. 从上图可看出，链式结构在逻辑上连续的，但在物理上不一定连续

  1. 现实中的结点一般都是在堆上申请出来的

  2. 从堆上申请的空间，是按照一定策略来分配的，两次申请的空间可能连续可能不连续

而链表的结构非常的多样:

1.单向 或 双向

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QNx1UFEN-1647616558484)(D:\Typora笔记\图片\image-20220313165635625.png)]

2.带头或 不带头

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N4nkrSMm-1647616558485)(D:\Typora笔记\图片\image-20220313165658050.png)]

3.循环或非循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ePJd2jCt-1647616558485)(D:\Typora笔记\图片\image-20220313165707436.png)]

虽然结构众多，但重点掌握两种:

  • **无头单向非循环链表:**结构简单，一般不会单独用来存储数据。实际中更多时作为其他数据结构的子结构，如哈希桶，图的邻接表等。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1o9J2R8z-1647616558486)(D:\Typora笔记\图片\image-20220313170012616.png)]

  • **无头双向链表:**在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

链表的模拟实现

无头单向非循环链表

// 1、无头单向非循环链表实现
public class SingleLinkedList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void toString();
    public void clear();
}

package singleLinkedList;

/**
 * Created with IntelliJ IDEA
 * Description:结点
 * User: 16037
 * Date: 2022-03-12
 * Time:14:25
 */
public class Node {
    public int val;         //结点值
    public Node next;       //下一个结点引用

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



/**

 * Created with IntelliJ IDEA
 * Description:无头单向非循环链表的简单模拟
 * User: 16037
 * Date: 2022-03-12
 * Time:14:28
   */

public class SingleLinkedList {
    public Node head;       //用成员变量来引用局部生成的Node，局部Node就不会被回收
    public int usedSize;
    
    //头插法
    public void addFirst(int data){
        Node node = new Node(data);
        node.next = this.head;
        this.head = node;
        this.usedSize++;
    }
    //尾插法
    public void addLast(int data) {
        Node node = new Node(data);
        if (this.head == null){
            this.head = node;
        }else {
            Node cur = this.head;
            while(cur.next!=null){
                cur = cur.next;
            }
            cur.next = node;
        }
        this.usedSize++;
    }

​    /**

   * 寻找下标为index的结点
      @param index

        * @return 存在返回下标为index的结点cur，否则返回null
          /
              private Node searchIndex(int index){
          //对index合法性判断
          if(index < 0 || index >= this.usedSize){
              return null;
          }

     Node cur = this.head;
     for(int i = 0;i < index;i++){
         cur = cur.next;
     }
     return cur;
         }
         //任意位置插入,第一个数据节点为0号下标
         public boolean addIndex(int index,int data){
     //头插
     if(index == 0){
         addFirst(data);
         return true;
     }
     //寻找index前一个，为头插时无法处理，列出处理
     Node cur = searchIndex(index-1);
     if(cur == null)
         return false;
     Node node = new Node(data);
     node.next = cur.next;
     cur.next = node;
     this.usedSize++;
     return true;
         }
         //查找是否包含关键字key是否在单链表当中
         public boolean contains(int key){
     Node cur = this.head;
     while(cur!=null){
         //引用类型 equals
         if(cur.val==key)
             return true;
         cur=cur.next;
     }
     return false;
         }

​    /**

   * 找到关键字key的前驱结点,默认初始prev为head
      @param key

        * @return 存在返回prev，不存在返回null
          /
              private Node findPrevKey(int key){

     Node prev = this.head;
     Node findKey = prev.next;
     while(findKey!=null){
         if(findKey.val == key){
             return prev;
         }
         prev = findKey;
         findKey = findKey.next;
     }
     return null;
         }
         //删除第一次出现关键字为key的节点
         public void remove(int key){
     //链表中无结点
     if(this.head == null){
         return;
     }

     //所删结点为头结点
     if(this.head.val == key){
         this.head = this.head.next;
         this.usedSize--;
         return;
     }

     Node prev = findPrevKey(key);
     //无关键字为key的前驱
     if(prev == null)
         return;

     Node del = prev.next;
     prev.next = del.next;
     this.usedSize--;

​    }
​    //删除所有值为key的节点
​    public void removeAllKey(int key){
​        Node del = this.head;
​        Node pre = null;
​        while(del!=null){
​            //所删结点为头结点
​            if(del.val==key && pre == null){
​                this.head = del.next;
​                del = del.next;
​                this.usedSize--;
​                continue;
​            }else if(del.val==key) {
​                pre.next = del.next;
​                del = del.next;
​                this.usedSize--;
​                continue;
​            }
​            pre = del;
​            del=del.next;
​        }
​    }
​    //得到单链表的长度
​    public int size(){
​        return this.usedSize;
​    }

​    @Override
​    public String toString(){
​        StringBuffer s = new StringBuffer();
​        if(this.head == null){
​            s.append("[]");
​            return s.toString();
​        }

​        s.append('[');
​        Node cur = this.head;
​        while(cur!=null){
​            s.append(cur.val);
​            if(cur.next != null)
​                s.append(',');
​            cur=cur.next;
​        }
​        s.append(']');
​        return s.toString();
​    }

​    public void clear(){
​        this.head = null;
​        this.usedSize = 0;
​    }
}

无头双向链表实现

// 2、无头双向链表实现
public class DoubleLinkedList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void toString();
    public void clear();
}

package doubleLinkedList;

/**
 * Created with IntelliJ IDEA
 * Description:
 * User: 16037
 * Date: 2022-03-13
 * Time:20:10
 */
public class Node {
    public int val;
    public Node prev;
    public Node next;

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



package doubleLinkedList;

/**
 * Created with IntelliJ IDEA
 * Description:
 * User: 16037
 * Date: 2022-03-16
 * Time:16:17
 */
public class DoubleLinkedList {
    public Node head;
    public Node last;
    public int usedSize;

    public void addFirst(int data){
        if(this.head == null){
            this.head = new Node(data);
            this.last = this.head;
        }else{
            Node node = new Node(data);
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
            this.last = node;
        }
        this.usedSize++;
    }
    public void addLast(int data){
        if(this.head == null){
            addFirst(data);
        }else{
            Node node = new Node(data);
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
            this.usedSize++;
        }
    }

    private Node searchByIndex(int index){
        Node cur = this.head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    public void addIndex(int index,int data){
        if(index < 0 || index > this.usedSize){
            throw new RuntimeException("下标越界！");
        }
        if(index == 0){
            addFirst(data);
        }
        if(index == this.usedSize){
            addLast(data);
        }
        Node next = searchByIndex(index);
        Node node = new Node(data);
        Node prev = next.prev;
        prev.next = node;
        node.prev = prev;
        node.next = next;
        next.prev = node;
        this.usedSize++;
    }

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

    private Node searchByKey(int key){
        Node cur = this.head;
        while(cur!=null){
            if(cur.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
    public void remove(int key){
        if(this.head == null){
            System.out.println("链表为空");
            return ;
        }
        Node del = searchByKey(key);
        if(del == null){
            throw new RuntimeException("无效关键字!");
        }

        if(del == this.head){               //删头结点
            this.head = this.head.next;
            if(this.head == null){      //只有一个结点
                this.last = null;
            }else{
                this.head.prev = null;
            }

        }else if(del == this.last){         //删除尾结点
            this.last = this.last.prev;
            this.last.next = null;
        }else{                              //删除中间结点
            Node prev = del.prev;
            Node next = del.next;
            prev.next = next;
            next.prev = prev;
        }
        this.usedSize--;
    }

    public void removeAllKey(int key){

        if(this.head == null){
            System.out.println("LinkedList is Null!");
            return ;
        }
        if(this.head.val == key && this.head.next == null){
            this.head = null;
            this.last = null;
            this.usedSize--;
            return ;
        }

        Node prev = this.head;
        Node cur = this.head.next;
        while(cur.next != null){
            if(cur.val == key){
                prev.next = cur.next;
                cur.next.prev = prev;
                cur = cur.next;
                this.usedSize--;
                continue;
            }
            cur = cur.next;
            prev = cur;
        }
        if(this.last.val == key){
            this.last = this.last.prev;
            this.last.next = null;
            this.usedSize--;
        }
        if(this.head.val == key){
            this.head = this.head.next;
            if(this.head == null){
                this.last = null;
            }else{
                this.head.prev = null;
            }
            this.usedSize--;
        }
    }

    public int size(){
        return this.usedSize;
    }

    public void clear(){
        Node cur = this.head;
        while(cur!= null){
            Node next = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = next;
        }
        this.head = null;
        this.last = null;
        this.usedSize = 0;
    }

    @Override
    public String toString() {
        StringBuffer str = new StringBuffer();
        if(this.head == null){
            str.append("[]");
            return str.toString();
        }
        str.append('[');
        Node cur = this.head;
        while(cur.next != null){
            str.append(cur.val);
            str.append(',');
            cur = cur.next;
        }
        str.append(cur.val);
        str.append(']');
        return str.toString();
    }
}

LinkedList的使用

什么是LinkedList

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TMP0zhFS-1647616558487)(D:\Typora笔记\图片\image-20220313170706769.png)]

在集合框架中，LinkedList也实现了List接口，具体如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IUuK0HZp-1647616558487)(D:\Typora笔记\图片\image-20220313170754251.png)]

【说明】

  1. LinkedList实现了List接口
  2. LinkedList的底层使用了双向链表
  3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
  4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

LinkedList的使用

LinkedList的构造

方法解释
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List
public static void main(String[] args) {
    // 构造一个空的LinkedList
    List<Integer> list1 = new LinkedList<>();
    List<String> list2 = new java.util.ArrayList<>();
    list2.add("JavaSE");
    list2.add("JavaWeb");
    list2.add("JavaEE");
    // 使用ArrayList构造LinkedList
    List<String> list3 = new LinkedList<>(list2);
}

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 subList(int fromIndex, int toIndex)截取部分 list

LinkedList的遍历

public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    list.add(1); // add(elem): 表示尾插
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);
    System.out.println(list.size());
    
    // foreach遍历
    for (int e:list) {
    	System.out.print(e + " ");
    } 
    System.out.println();
    // 使用迭代器遍历---正向遍历
    ListIterator<Integer> it = list.listIterator();
    while(it.hasNext()){
    	System.out.print(it.next()+ " ");
    } 
    System.out.println();
    // 使用反向迭代器---反向遍历
    ListIterator<Integer> rit = list.listIterator(list.size());
    while (rit.hasPrevious()){
    	System.out.print(rit.previous() +" ");
    } 
    System.out.println();
}

最难不过坚持！

阿辉爱睡觉
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 -- 链表（LinkedList）
qq_41217625的博客
11-24 139
一、简介 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 　　每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O...
链表(LinkedList) C 语言实现
热门推荐
song_hui_xiang
07-24 1万+
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。如图： 下面是代码实现： #include #include struct student { int score; struct student *next; }; typedef struct student NODE; //typedef为C语言的关
【数据结构】LinkedList与链表
Living_Amethyst的博客
05-11 593
【引言】 上篇文章我们介绍了ArrayList的使用以及它的一些相关知识，还模拟实现了简单的顺序表 我们在这个过程中，有了以下的思考：ArrayList的底层是使用数组来存储元素的 这就导致当ArrayList的任意位置插入或删除元素时，就需要将后续元素整体向后移或者向前移，所以时间复杂度为O(N) 因此ArrayList不适合做任意位置插入和删除比较多的场景 所以，Java集合中又引入了LinkedList，即链表结构 1.链表 1.1链表的概念和结构 ......
边学边记——Java数据结构☞LinkedList（链表）的介绍及自我实现
lil_ghost_的博客
10-18 658
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。理论：链表也是一种线性表。线性表集合：逻辑上元素和元素有前后顺序，但不保证这些元素按照逻辑的顺序存储。自定义实现线性表（接口MyList）和链表表（类MyLinkedList）。
数据结构-链表（Linked List）的介绍与代码实现
GGB__的博客
09-12 395
文章目录一、链表是什么？二、单链表的实现1.需要实现的方法：2.引入内部Node(节点)类：3.在链表的任意位置添加元素：4.删除链表中任意位置的元素：5.更新链表中任意位置的元素：6.整体实现方法：三、单链表实现栈与队列1.实现栈：1.实现栈：2.实现队列：四、补充 一、链表是什么？ 这里引入百度百科的解释： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。相比于线性表顺序结构，操作复杂。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可
linkedlist_链表_
10-02
单双链表的创建，节点的添加与删除，链表逆序，链表遍历。
LinkedList:链表
07-03
链表Shashank Shekhar 的链接列表实现
LinkedList:链表算法
04-13
链表 链表算法 链表算法的实现，该算法从stdin读取用户命令并根据用户指令命令在链表上运行特定功能，例如：PUT n，GET n，LIST，FIRST，LAST，SORT，CLEAR，REMOVE n，EXIT，其中： PUT n-将一个整数n插入到链表中...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
数据结构-链表(LinkedList)介绍与实现
qq_39225639的博客
09-01 1809
数据结构-链表介绍链表的特点链表和数组的区别优点缺点链表的组成链表的常见方法链表的实现 介绍 链表和数组一样，都用来存储一系列的元素。但是链表和数组实现的机制完全不同。从而导致其相关操作的效率也有所不同。 链表的特点 链表是一种物理存储单元上非连续、非顺序的存储结构 链表直观形态，每个节点元素都有保存了下一个节点的引用，头部指向第一个节点，最后一个节点指向null。 链表和数组的区别 优点 链表存储空间是非连续的而数组的存储空间是连续的。因此链表的内存利用率会更高一点。 链表在头部插入元素和中间插入
集合框架（2）——LinkedList（链表）
aigo_2021的博客
02-05 937
一、 LinkedList（链表） 每个元素有几个属性，存储值、存储上一个元素的引用(地址)、存储下一个元素的引用(地址) LinkedList是双向链表的数据结构 LinkedList源码实现 1.定义Node内部类 //定义一个节点类 （内部类） class Node{ private Node prev;//左节点，存储上一个元素的地址 private Node next;//右节点，存储下一个元素的地址 private Object data;//数据域，存储
数组和链表的区别、ArrayList和LinkedList的区别、使用LinkedList模拟栈和队列
终生学习践行者
07-24 4040
介绍了数组和链表的区别，ArrayList和LinkedList的区别以及使用LinkedList模拟栈和队列。
链表及LinkedList详解
chaosongcc的博客
07-17 2585
何为链表 链表就是一种使用对象引用变量来创建对象间的链的数据结构.对象引用变量可用于创建链式结构,对象引用变量所存储的特点地址一般无关紧要.换句话说,重要的是能够使用引用变量来访问对象,而对象在内存中的位置并不重要 下面这个类就是一个链式结构: public class Person{ private String name; private int age; p...
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1131
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring Bean Map之舞
m0_51176516的博客
05-23 221
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 277
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
Java高级面试精粹：问题与解答集锦（一）
最新发布
Layla_c的博客
05-23 748
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 378
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Linkedlist双向链表
03-29
与单向链表不同，双向链表可以在任何一个节点中进行插入和删除操作，因为每个节点都包含指向前一个节点和后一个节点的指针。 双向链表的优点是可以很方便地在任何位置进行插入和删除操作，但它的缺点是需要更多的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值