【Java数据结构】线性表-链表

已于 2023-04-14 20:02:32 修改
阅读量440 收藏
点赞数 1
分类专栏： Java数据结构 文章标签： 链表 数据结构 java
于 2023-04-14 20:02:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72670269/article/details/130132010
版权

线性表-链表

链表的概念及结构

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

链表在物理上不连续 在逻辑上连续
在这里插入图片描述
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
1. 单向或者双向
2. 带头或者不带头
3. 循环或者非循环

在这么多链表结构中我们主要学习两种

  1. **无头单向非循环链表：**无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多
  2. 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

实现无头单向非循环链表

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

实现上面的接口即可

public class SingleLinkedList {

	//内部类 实现了一个节点
    static class ListNode {
        public int val;
        //节点的值
        public ListNode next;
        //节点中储存了下一个节点的地址
        public ListNode(int val) {
            this.val = val;
        }
        //初始化节点的构造方法
    }
    //永远指向头节点
    public ListNode head;

	//打印链表中所有节点的值
    public void show() {
        ListNode cur = head;
        //记录头节点的位置 遍历不改变头节点位置
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
            //当cur不为空时 打印每个节点的val值 使cur指向下一个节点
        }
        System.out.println();
    }
	

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        //新建一个节点 将这个节点头插
        node.next = head;
        //将新节点指向头节点 成为新的头节点
        head = node;
        //head永远指向头节点 head也改为node
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        //新建一个节点 将这个节点尾插
        if (head == null) {
            head = node;
            //如果此时链表为空 那么该节点就是新的头节点
            return;
        }
        ListNode cur = head;
        //记录头节点
        while (cur.next != null) {
            cur = cur.next;
        }
        //此时cur指向的就是最后一个节点
        //只需要把最后一个节点指向node
        cur.next = node;
    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        int len = size();
        //判断下标的合法性
        if (index < 0 || index > len) {
            throw new IndexOutOfBoundsExcption("在任意位置插入数据时，index位置不合法: " + index);
        }
        //如果插入位置时头位置 则是头插
        if (index == 0) {
            addFirst(data);
        }
        //如果插入位置时尾部 则是尾插
        if (index == len) {
            addLast(data);
        }
    }

    //查找是否包含关键字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;
        }
        //如果头节点是要移除的节点
        if (head.val == key) {
            head = head.next;
            return;
        }
        ListNode prev;
    }

    //查找目标节点的上一个节点
    private ListNode searchPrev(int key) {
        ListNode prev = head;
        while (prev.next != null) {
            if (prev.next.val == key) {
                return prev;
            } else {
                prev = prev.next;
            }
        }
        return null;
    }

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

    //得到单链表的长度
    public int size() {
        int count = 0;
        ListNode cur = head;
        //如果是引用类型用equals比较
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    public void clear() {
        //this.head = null;
        while (head != null) {
            ListNode headNext = head.next;
            head.next = null;
            head = headNext;
        }
    }

    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.println(cur.val);
            cur = cur.next;
        }
    }
}

LinkedList 模拟实现

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;

    //获取链表的长度
    public int size() {
        int len = 0;
        ListNode cur = head;
        //遍历链表求长度
        while (cur != null) {
            len++;
            cur = cur.next;
        }
        return len;
    }

    //打印链表内容
    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val);
            cur = cur.next;
        }
        System.out.println();
    }

    //查找某个关键字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 addFirst(int data) {
        ListNode node = new ListNode(data);
        //如果链表为空 插入的同时初始化头节点和尾节点
        if (head == null) {
            head = node;
            last = node;
            return;
        }
        node.next = head;
        head.prev = node;
        head = node;
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
            last = node;
            return;
        }
        node.prev = last;
        last.next = node;
        last = node;
    }


    public void addIndex(int index, int data) {
        int size = size();
        if (index < 0 || index > size) {
            throw new IndexOutOfBounds("双向链表index下标不合法：" + index);
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size) {
            addLast(data);
            return;
        }
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        ListNode node = new ListNode(data);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

    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;
                    } else {
                        last = null;
                        //此时head = head.next head已经为null
                        //只需要将last也置为null即可
                    }
                } else {
                    cur.prev.next = cur.next;
                    //将cur之前的节点next指向改为cur的下一个节点
                    //判断cur是否为尾节点
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                        //将后面节点的prev指向cur的prev
                    } else {
                        last = cur.prev;
                        //如果为最后一个节点 就把last向前移
                    }
                }
                return;
            } else {
                cur = cur.next;
            }
        }
    }
    public void removeAllKey(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 {
                        last = null;
                        //此时head = head.next head已经为null
                        //只需要将last也置为null即可
                    }
                } else {
                    cur.prev.next = cur.next;
                    //将cur之前的节点next指向改为cur的下一个节点
                    //判断cur是否为尾节点
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                        //将后面节点的prev指向cur的prev
                    } else {
                        last = cur.prev;
                        //如果为最后一个节点 就把last向前移
                    }
                }
            }
            cur = cur.next;
        }
    }

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

ArrayList和LinkedList的区别

在这里插入图片描述

沉着的码农
关注
专栏目录
线性表-链表
RenPeng_Ben的博客
08-01 492
链表 概论 wikipedia:链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数
【数据结构】线性表----链表（LinkedList）
m0_47916948的博客
02-04 174
链表：处在不连续的内存空间上 链表优点：解决顺序表的搬运，增加或者删除操作## 标题 单向链表 class Node{ int val; //保存我们的元素 Node next;//保存下一个元素的引用。 } 上面为单向链表：只能从上一个节点找到下一个节点 双向链表 class Node{ int val; //保存我们的元素 Node prev;//保存上一个元素的引用。 Node next;//保存下一个元素的引用。 } 链表分类 **单向链表 vs 双链表 有
java实现链表型线性表
hello world
06-14 933
线性表接口如下 package IntefaceList; public interface IList&lt;T&gt; { /** * 构造一个空的线性表 进行初始化 */ void InitList(); /** * 销毁线性表 */ IList DestroyList(); /** * 将...
线性表
weixin_42579576的博客
06-29 288
1. 线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 **前驱元素：**若A元素在B元素的前面，则称A为B的前驱元素 **后继元素：**若B元素在A元素的后面，则称B为A的后继元素 **线性表的特征：**元素之间具有“一对一”的逻辑关系 第一个元素没有前驱元素，被称为头结点 最后一个数据元素没有后继，这个数据元素被称为尾结点 其余中间元素有且只有一个前驱元素和后继元素 1.1 顺序表 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺
Java--线性链表(带动态图)
RAVANLALA
10-09 291
线性链表 public class LinkList{ Node head; Node tail; public LinkList(){// head = new Node; tail = head; } void Insert(Node e, Node p){ p.next = e.next; e.next = p; } Insert void Delete...
线性链表java实现_java实现线性单链表
weixin_28738165的博客
02-27 125
/****线性单链表*/publicclassLinkedLinearList{privateNodehead;privateintlength;//实际长度/***初始化顺序表,长度为length*/publicLinkedLinearList(){length=0;head=newNode('0',null);length++;}/***将index位置赋...
java 用链表实现线性表
分享技术，享受生活
08-05 1475
package com.jzm; public class MyLList { private Node firstNode; private int length; //线性表的长度 private
数据结构线性表-顺序表（c++、java）.pdf
最新发布
11-12
顺序表是一种基本的数据结构，它在线性表的基础上采用了顺序存储的方式...在实际编程中，应考虑优化这些操作的效率，例如通过数组扩容策略减少频繁的内存分配，或者使用其他数据结构（如链表）来提高插入和删除的效率。
Java-数据结构课设-链表实现通讯录管理系统
10-07
一、用链表或者顺序表实现以下系统，完成线性表的建立（至少包括10个结点），以及线性表中信息（结点）的插入、查找、删除、修改、输出等操作，具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1...
Java数据结构 线性表，链表，哈希表是常用的数据结构
03-04
Java数据结构 线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构
Java数据结构——线性单链表的实现
It一zhai男
10-26 1376
Java数据结构——线性单链表的实现一、描述 线性表的链式存储结构的特点：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此它没有顺序存储结构所具有的弱点（顺序存储结构插入数据或删除数据都要移动大量的数据），但同时也失去了顺序表可随机存取的优点。单链表的组成为：数据信息和指向下一个节点的指针。二、源码2.1 节点信息Node.javapackage com
线性链表 java实现
小东的专栏
11-18 456
public class LinkList { class Node{//定义Node节点 private T data; private Node next; public Node(){} public Node(T data,Node next){ this.data=data; this.next=next; } } private Node hea
java数据结构与算法-线性表与链表（2）
u013930163的博客
05-11 967
上一会我们讲到了在java中线性表和链表的创建，数据的添加和删除所消耗的代价。
线性链表java实现_【数据结构】线性链表的Java实现
weixin_31738297的博客
02-27 141
public class LinkedList {public ListNode head;public ListNode current;class ListNode{int val; //数据域ListNode next = null; //指针域public ListNode(int val) {this.val =val;}}//尾插法建立单链表public void CreateLi...
JAVA 实现线性表之链表
u010943460的专栏
08-31 751
JAVA 实现线性表之链表
线性表——单链表（java）
MADE_哒哒
02-06 268
         一、单链表是一种链式存取的数据结构。是由若干个结点组成的，每个结点由：元素(数据元素的映象) + 指针(指示后继元素存储位置)两部分组成。需要注意的是结点的地址是随机给定的。 在逻辑上可以理解为这样的：                    上图是不带头结点的单链表         单链表的一个重要特征就是能从前驱结点找到后继结点。而无法从后继结点找前驱结点。因为这种最...
Java实现链表，线性表
每一个不曾起舞的日子，都是对人生的辜负。
03-21 354
List package MyList; public interface List { abstract public int size(); abstract public boolean empty(); abstract public Object at(int index); abstract public List indexOf(Object ...
java线性表(三)-------链表
ZhaFi人
11-05 179
单链表 之前我们已经使用顺序存储结构实现了线性表，我们会发现虽然顺序表的查询很快，时间复杂度为O(1),但是增删的 效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可以 使用另外一种存储结构实现线性表，链式存储结构。 链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元 素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成， 结点可以在运行时动态生成。 .
Java实现链表
cainiaowangdake的博客
06-06 1312
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
Java实现模板顺序线性表 - 数据结构基础
"这篇资源是关于使用Java语言模板实现顺序表示的线性表的数据结构教程。作者张宏探讨了数据结构的基本概念，包括算法、数据结构的定义、数据元素、逻辑结构和物理结构等，强调了数据结构在编写高效程序中的重要性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沉着的码农

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

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

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

打赏作者

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

抵扣说明：

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

余额充值