Java————链表

于 2024-07-25 09:49:59 发布
阅读量700 收藏 10
点赞数 12
文章标签： java 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80251684/article/details/140659035
版权

目录

前言：

1.链表的概念

2.链表的结构

2.1带头的和不带头的

2.2单向和双向

2.3循环和非循环

3.链表的实现

3.1双向不带头不循环链表：

3.2单向不带头不循环链表：

4.LinkedList的使用

4.1什么是LinkedList

4.2LinkedList的使用

5.LinkedList的遍历

5.1foreach遍历

5.2使用迭代器遍历---正向遍历

5.3使用迭代器遍历---反向遍历

前言：

由于顺序表底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java 集合中又引入了LinkedList，即链表结构。

1.链表的概念

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

注意：

1.链式结构在逻辑上是连续的，在物理上不一定是连续的

2.现实中的节点一般都是从堆上申请出来的

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

2.链表的结构

链表有2的3次方种结构：

总的可以分为三类：带头的和不带头的，单向的和双向的，循环和不循环的

2.1带头的和不带头的

上面是单向不循环的带头和不带头的两个链表

注意：

1.带头链表的第一个节点叫做哨兵位，这个节点不存储有效内容

2.每一个节点的next引用指向下一个节点

2.2单向和双向

2.3循环和非循环

虽然总的链表有8种结构，但需要重点掌握的只有两种：

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

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

3.链表的实现

3.1双向不带头不循环链表：

IList：

package OneList;

public interface IList {

//头插法
        public void addFirst(int data);
 //尾插法
         public void addLast(int data);
 //任意位置插入,第一个数据节点为0号下标
         public void 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 clear();
//打印链表
         public void display();
}

方法的实现：

package OneList;

public class MyList implements IList{
    static class Node{
        Node prv;
        Node next;
        int x;
        public Node(int x) {
            this.x = x;
        }
    }

    private int size=0;
    private Node head=null;
    private Node tail=null;

    @Override
    public void addFirst(int data) {
        Node node=new Node(data);
if (head==null){
    head=node;
    tail=node;
}else {
    node.next=head;
    head.prv=node;
    head=node;
}
size++;
    }

    @Override
    public void addLast(int data) {
        Node node=new Node(data);
        if (head==null){
            head=node;
            tail=node;
        }else {
        node.prv=tail;
        tail.next=node;
        tail=node;
        }
        size++;
    }

    @Override
    public void addIndex(int index, int data) {
        Node node=new Node(data);
if (index<0||index>size){
    return ;
}
if (index==0){
    addFirst(data);
}
else if (index==size){
    addLast(data);
}else {
    Node cur=head;
    while (index>1){
        cur=cur.next;
        index--;
    }
    Node t=cur.next;
    node.next=t;
    t.prv=node;
    cur.next=node;
    node.prv=cur;
    size++;
}
    }

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

    @Override
    public void remove(int key) {
        if (head==null){
            return;
        }

        if (head.x==key){
            head=head.next;
            head.prv=null;
            size--;
        }
        Node cur=head;
        while (cur.next!=null){
            if(cur.x==key){
                cur.prv.next=cur.next;
                cur.next.prv=cur.prv;
                size--;
                return;
            }
            cur=cur.next;
        }
        if (cur.x==key){
            tail=tail.prv;
            tail.next=null;
            size--;
        }
    }

    @Override
    public void removeAllKey(int key) {
if (head==null){
    return;
}
Node cur=head;
while (cur!=null){
    if(cur.x==key&&cur==head){
        head=head.next;
        cur=cur.next;
        head.prv=null;
        size--;
    } else if (cur.x==key&&cur==tail) {
        tail=tail.prv;
        tail.next=null;
        size--;
    }else if (cur.x==key){
        cur.prv.next=cur.next;
        cur.next.prv=cur.prv;
        cur=cur.next;
        size--;
    }else {
        cur=cur.next;
    }
}


    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void clear() {
Node cur=head;
Node next=cur.next;
while (next!=null){
    cur=null;
    cur=next;
    next=next.next;
}
cur=null;
head=null;
tail=null;
    }

    @Override
    public void display() {
if (head==null){
    return;
}
Node cur=head;
while (cur!=null){
    System.out.print(cur.x+" ");
    cur=cur.next;
}
        System.out.println();
    }
}

3.2单向不带头不循环链表：

IList：

package List;

public interface IList {
  //头插法
         public void addFirst(int data);
 //尾插法
         public void addLast(int data);
 //任意位置插入,第一个数据节点为0号下标
         public void 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 display();
 //清空链表
 public void clear();


    }

MyList：

package List;

import java.awt.*;

public class MyList implements IList{

    static class Node{
        int val;
        Node next;

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

    private int size=0;
    private Node head=null;


    @Override
    public void addFirst(int data) {
        Node node=new Node(data);
        if (head==null){
            head=node;
        }else {
            node.next=head;
            head=node;
        }
        size++;
    }

    @Override
    public void addLast(int data) {
Node node=new Node(data);
if (head==null){
    head=node;
}else {
    Node cur=head;
    while (cur.next!=null){
        cur=cur.next;
    }
    cur.next=node;
}
size++;
    }

    @Override
    public void addIndex(int index, int data) {
if (index<0||index>size){
    return;
}
Node node=new Node(data);
if (index==0){
    addFirst(data);
}
else if (index==size){
    addLast(data);
}else {
    Node cur=head;
    while (index>1){
        cur=cur.next;
        index--;
    }
    node.next=cur.next;
    cur.next=node;
    size++;
}



    }

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

    @Override
    public void remove(int key) {
        if (head == null) {
            return;
        }
        Node cur = head;
        if (head.val == key) {
            head = head.next;
            size--;
            return;
        }
        while (cur.next != null) {
            if (cur.next.val == key) {
                cur.next = cur.next.next;
                size--;
                return;
            }
            cur = cur.next;
        }
        if (cur.val==key){
            cur=null;
            size--;
        }
    }
    @Override
    public void removeAllKey(int key) {
        if (head==null){
            return;
        }
while(head.val==key){
    head=head.next;
    size--;
}
        Node cur=head;
Node next=head.next;
while (next.next!=null){
    if (next.val==key){
        cur.next=next.next;
        next=next.next;
        size--;
    }else {
        next=next.next;
    cur=cur.next;
    }
}
if (next.val==key){
    cur.next=null;
    size--;
}

    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void display() {
Node cur=head;
while (cur!=null){
    System.out.print(cur.val+" ");
    cur=cur.next;
}
        System.out.println();
    }

    @Override
    public void clear() {
        Node cur=head;
        Node next=cur.next;
        while (next!=null){
            cur=null;
            cur=next;
            next=next.next;
        }
        cur=null;
        head=null;
    }
}

4.LinkedList的使用

4.1什么是LinkedList

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

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

说明：

1. LinkedList实现了List接口

2. LinkedList的底层使用了双向链表

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

4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

5. LinkedList比较适合任意位置插入的场景

4.2LinkedList的使用

构造方法：

LinkedList()无参构造
public LinkedList(Collection 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 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

 方法练习使用：

package Test;

import java.util.LinkedList;

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer>list=new LinkedList<>();
        //尾插
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list);
        //指定位置插入
list.add(0,0);
        System.out.println(list);
        list.add(list.size(), 6);
        System.out.println(list);
        list.add(5,6);
        System.out.println(list);
        //头插
        list.addFirst(-1);
        System.out.println(list);
        //尾插
        list.addLast(100);
        System.out.println(list);
        System.out.println("========================================");
        //判断元素是否存在
        System.out.println(list.contains(1));
        //获取下标元素
        System.out.println(list.get(1));
        //获取第一个元素
        System.out.println(list.getFirst());
//获取最后一个元素
        System.out.println(list.getLast());
        //修改指定位置的元素
        list.set(4,99999);
        System.out.println(list);
        //返回第一次出现元素的下标
        System.out.println(list.indexOf(100));
//返回最后一次出现元素的下标
        System.out.println(list.lastIndexOf(2));
//截取指定区间的元素（左闭右开）
        System.out.println(list.subList(1, 4));
    }

}

5.LinkedList的遍历

5.1foreach遍历

      for (int x:list) {
            System.out.print(x+" ");
        }

5.2使用迭代器遍历---正向遍历

    ListIterator<Integer>lit= list.listIterator();
        while (lit.hasNext()){
            System.out.print(lit.next()+" ");
        }

5.3使用迭代器遍历---反向遍历

   ListIterator<Integer>it= list.listIterator();
        while (it.hasPrevious()){
            System.out.print(it.previous()+" ");
        }
鱼骨不是鱼翅
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java——HashMap
12-21
Java——HashMap HashMap 底层: 哈希表存储(数组+链表+红黑树) 特点: 查询,增删效率高,但是无序,存储键值对的值 去重: 根据key做去重,根据key计算桶的位置 扩容: 初始容量: 默认初始用量为16 加载因子: 0.75 当16*...
JAVA——坦克大战.rar
09-27
《JAVA——坦克大战》 Java作为一种跨平台的编程语言，其强大的面向对象特性和丰富的类库使得它在游戏开发领域也有广泛的应用。本资源“JAVA——坦克大战.rar”提供了一个基于Java实现的经典游戏——坦克大战的源...
JAVA——链表
热门推荐
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
java——链表实现队列
2301_77713282的博客
01-23 858
链表队列, 队列的实现, 选择头结点作队头还是尾结点作队头, 两种方式的时间复杂度分析
Java——反转链表
申俏雅的博客
03-21 989
输入：head = [1,2,3,4,5], left = 2, right = 4。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,3,4,5]来源：力扣（LeetCode）来源：力扣（LeetCode）输出：[5,4,3,2,1]输出：[1,4,3,2,5]
Java基础——链表
qq_52519008的博客
06-14 3209
　　单向链表只有一个指针域，在整个节点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的节点。 单向链表中，每个节点的数据域都是通过一个 Object 类的对象引用来指向数据元素的，与数组类似，单向链表中的节点也具有一个线性次序，即如果节点 a1 的 next 引用指向节点 a2，则 a1 就是 a2 的直接前驱，a2 是 a1 的直接后续。只能通过前驱节点找到后续节点，而无法从后续节点找到前驱节点。 特点： 　　数据元素的存储对应的是不连续的存储空间，每个存储结点对应一个需要存储的数据元素。每个
JAVA——链表分割
SwitchD的博客
02-07 553
问题：现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。 方法：把所有的数分成两组，小于x的一组，大于等于x的一组。小于x的数以bs开头be结尾；大于等于x的数以as开头，ae结尾。若cur=null则循环结束。 之后要判断bs是否为空，以及as是否为空的情况。 代码： public ListNode partition(ListNode pHead, int x) { /
java——ArrayList-源码解析.docx
05-09
ArrayList 是 Java 中常用的集合类，它是 List 接口的一个实现，基于数组进行操作。ArrayList 的设计使得元素可以动态地添加和删除，同时提供了对数组大小的灵活调整。它实现了 ICollection 和 IList 接口，提供了...
数组和链表——精选推荐 数组和链表.pdf
04-18
下面我们将详细介绍数组和链表的基本组成部分、特点和Java实现。 一、数组 数组是最常用的线性数据结构，数组中的元素类型是一样的，并且有序的。数组的特点是： * 数据是连续的 * 随机访问速度快 在Java中，...
Java大作业——五子棋.zip
06-15
这可能需要用到深度优先搜索（DFS）或广度优先搜索（BFS）等图论算法，以及数组或链表等数据结构来存储棋盘状态。 7. **设计模式**：在编写代码时，可以运用工厂模式创建棋子，单例模式管理棋盘，观察者模式实现...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1130
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 403
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 443
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 771
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 785
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 131
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 322
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 972
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 820
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值