【数据结构】——链表 (链式存储和基于Java的运算实现)

最新推荐文章于 2023-12-17 14:25:24 发布
最新推荐文章于 2023-12-17 14:25:24 发布
阅读量641 收藏 5
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fhsbvs/article/details/121096634
版权

目录

单链表 (线性链表)

单链表的基本运算

头插法

尾插法

查找运算

插入运算

删除运算

代码实现

一、结点类

二、链表类

三、操作类

四、测试类

循环链表

双向链表

顺序表和链表的比较

单链表 (线性链表)

概述：链式存储表示每个数据元素a[i]时，除了存储a[i]本身信息之外，还需要一个存储指示其后继元素a[i+1]存储位置的指针。

包括两个域：存储数据元素的域称为数据域，存储直接后继存储地址的域称为指针域。

空链表：head=NULL

图示：

单链表的基本运算

头插法

概述：从一个空表开始，重复读入数据，生成新结点，将读入的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头上，直到读入结束标志为止。

图解：

尾插法

概述：将新结点插入在当前链表的表尾上，因此需要增设一个尾指针rear，使其始终指向链表的尾结点。

图解：

查找运算

按结点序号查找

概述：从链表第一个结点开始，p指向当前结点，j为计数器，初始值为1，当p扫描下一个结点时，计数器加1。当j=i时，指针p所指向的结点就是要找的结点。平均时间复杂度：O(n)

按结点值查找

概述：从链表的开始结点出发，顺链逐个将结点的值和给定的值k进行比较，若遇到相等的值，则返回该结点的储存位置，否则返回NULL。时间复杂度：O(n)

插入运算

概述：先使p指向a(i-1)的位置，然后生成一个数据域值为x的新结点*s，再进行插入操作。

图解：

时间复杂度：O(n)

删除运算

概述：先使p指向第i-1个结点，然后再使得p—>next指向第i+1个结点，再将第i个结点释放掉。

图解：

时间复杂度：O(n)

代码实现

一、结点类

//链表结点类
public class Node {
    //数据域
    private Object data;
    //指针域
    private Node next;

    public Node() {
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "\nNode{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}

二、链表类

//链表类
public class LinkList {
    //头结点
    Node head;
    //链表长度
    int size;

    //构造方法
    public LinkList() {
        head = null;
        size = 0;
    }

    @Override
    public String toString() {
        return "LinkList{" +
                "head=" + head +
                ", size=" + size +
                '}';
    }
}

三、操作类

//操作类
public class SingleLinkedList {
    //定义一个单链表
    static LinkList linkList = new LinkList();
    //定义一个尾指针
    static Node rear = linkList.head;

    //头插法建表
    public static void CreateListF(Node node) {
        //申请新结点
        Node n = new Node();
        //数据域赋值
        n.setData(node.getData());
        //指针域赋值
        n.setNext(linkList.head);
        //头指针指向新结点
        linkList.head = n;
        //链表长度加1
        linkList.size++;
    }

    //尾插法建表
    public static void CreateListR(Node node) {
        //申请新结点
        Node n = new Node();
        //数据域赋值
        n.setData(node.getData());
        //判断链表是否为null，并插入新结点
        if (linkList.head == null) {
            linkList.head = n;
        } else rear.setNext(n);
        //尾指针指向新结点
        rear = n;
        //终端结点指针域置空
        if (rear.getNext() != null)
            rear.setNext(null);
        //链表长度加1
        linkList.size++;
    }

    //遍历
    public static void ListShow() {
        //定义一个新结点，用于循环赋值显示
        Node n = linkList.head;
        //循环链表
        for (int i = 0; i < linkList.size; i++) {
            //输出新结点的数据值
            System.out.println(n.getData());
            //新结点指向下一个结点
            n = n.getNext();
        }
    }

    //查找：按结点序号查找,返回该结点
    public static Node GetNodeI(int i) {
        //判断查找的序号是否合法
        if (i <= 0 || i > linkList.size) {
            System.out.println("position error!");
        }
        //定义一个新结点并赋值
        Node n = linkList.head;
        //序号无负数，从1开始
        for (int j = 1; j <= linkList.size; j++) {
            if (i == j) {
                break;
            }
            //新结点指向下一个结点
            n = n.getNext();
        }
        return n;
    }

    //查找：按结点值查找,参数为结点值
    public static Node GetNodeK(Object n) {
        //判断链表是否为空
        if (linkList.size == 0) {
            System.out.println("LinkList is null!");
        }
        //判断结点值是否与头结点相等
        if (n == linkList.head.getData()) {
            return linkList.head;
        }
        //定义一个新结点并赋值
        Node newNode = linkList.head;
        while (linkList.size > 0) {
            if (newNode.getData() == n) {
                return newNode;
            }
            //新结点指向下一个结点
            newNode = newNode.getNext();
            linkList.size--;
        }
        return null;
    }

    //插入：将值为x的新结点插入到第i个结点的位置上
    public static void InsertList(int i, Object x) {
        //判断插入的位置是否合法
        if (i <= 0 || i > linkList.size) {
            System.out.println("position error!");
        }
        //链表长度加1
        linkList.size++;
        int k = 1;
        //创建新结点并赋值
        Node p = linkList.head;
        //使p指向i-1个结点
        while (p != null && k < i - 1) {
            p = p.getNext();
            k++;
        }
        //申请一个新结点
        Node newNode = new Node();
        //数据域赋值
        newNode.setData(x);
        //指针域赋值
        newNode.setNext(p.getNext());
        //i-1个结点指向新节点
        p.setNext(newNode);
    }

    //删除：将链表中的第i个结点删除,并返回该值
    public static Object DeleteList(int i) {
        //判断要删除的位置是否合法
        if (i <= 0 || i > linkList.size) {
            System.out.println("position error!");
        }
        int n = 1;
        //创建新结点并赋值
        Node p = linkList.head;
        //使p指向i-1个结点
        while (p != null && n < i - 1) {
            p = p.getNext();
            n++;
        }
        //定义一个新结点,指向第i个结点
        Node s = p.getNext();
        //使p的下一个结点指向i+1个结点
        p.setNext(s.getNext());
        //保存被删除结点的值
        Object x = s.getData();
        linkList.size--;
        return x;
    }
}

四、测试类

4.1 建立单链表测试

4.1.1 头插法建表

public class SingleLinkedListTest {
    public static void main(String[] args) {
        //创建结点值
        Node n1 = new Node("qq", null);
        Node n2 = new Node("ww", null);
        Node n3 = new Node("ee", null);
        Node n4 = new Node("rr", null);
        //头插法
        SingleLinkedList.CreateListF(n1);
        SingleLinkedList.CreateListF(n2);
        SingleLinkedList.CreateListF(n3);
        SingleLinkedList.CreateListF(n4);

        System.out.println(SingleLinkedList.linkList);
    }
}

运行结果：

4.1.2 尾插法建表

public class SingleLinkedListTest {
    public static void main(String[] args) {
        //创建结点值
        Node n1 = new Node("qq", null);
        Node n2 = new Node("ww", null);
        Node n3 = new Node("ee", null);
        Node n4 = new Node("rr", null);
        //尾插法
        SingleLinkedList.CreateListR(n1);
        SingleLinkedList.CreateListR(n2);
        SingleLinkedList.CreateListR(n3);
        SingleLinkedList.CreateListR(n4);

        System.out.println(SingleLinkedList.linkList);
    }
}

运行结果：

4.2 基本操作测试

说明：上边使用的头插法和尾插法是为了创建链表，只需要选择其中的一种创建方式即可。尾插法创建出来的链表跟我们插入的顺序是一样的，更符合实际，为了测试时方便查验，下边对链表的测试都是基于尾插法建立的表进行测试的。

public class SingleLinkedListTest {
    public static void main(String[] args) {
        //创建结点值
        Node n1 = new Node("qq", null);
        Node n2 = new Node("ww", null);
        Node n3 = new Node("ee", null);
        Node n4 = new Node("rr", null);
        //尾插法
        SingleLinkedList.CreateListR(n1);
        SingleLinkedList.CreateListR(n2);
        SingleLinkedList.CreateListR(n3);
        SingleLinkedList.CreateListR(n4);

        System.out.println(SingleLinkedList.linkList);
        System.out.println("---------------------------------");

        //遍历
        System.out.println("链表元素遍历为：");
        SingleLinkedList.ListShow();
        System.out.println("---------------------------------");

        //查找：按结点序号
        Node node = SingleLinkedList.GetNodeI(1);
        System.out.println("结点序号为1的元素值为：" + node.getData());
        System.out.println("---------------------------------");

        //查找：按结点值查找
        Node node1 = SingleLinkedList.GetNodeK("ww");
        System.out.println("元素值是‘ww’的结点为：" + node1);
        System.out.println("---------------------------------");
    }
}

运行结果：

4.3 插入删除测试

public class SingleLinkedListTest {
    public static void main(String[] args) {
        //创建结点值
        Node n1 = new Node("qq", null);
        Node n2 = new Node("ww", null);
        Node n3 = new Node("ee", null);
        Node n4 = new Node("rr", null);
        //尾插法
        SingleLinkedList.CreateListR(n1);
        SingleLinkedList.CreateListR(n2);
        SingleLinkedList.CreateListR(n3);
        SingleLinkedList.CreateListR(n4);

        System.out.println(SingleLinkedList.linkList);
        System.out.println("---------------------------------");

        //插入
        SingleLinkedList.InsertList(3, "66");
        //遍历
        System.out.println("插入结点之后遍历链表为：");
        SingleLinkedList.ListShow();
        System.out.println("---------------------------------");

        //删除
        Object o = SingleLinkedList.DeleteList(4);
        System.out.println("被删除的元素值为："+o);
        //遍历
        System.out.println("删除结点之后遍历链表为：");
        SingleLinkedList.ListShow();
        System.out.println("---------------------------------");
    }
}

运行结果：

循环链表

概述：单链表中最后一个结点的指针域不为空，而是指向链表的头结点，使整个链表构成一个环。

图示：

双向链表

概述：链表中有两条不同方向的链。

图示：

顺序表和链表的比较

时间性能：对于查找运算顺序表的时间复杂度为O(1)，链表的时间复杂度为O(n)，顺序表更好。

空间性能：事先知道数据量的大小使用顺序表更好，否则链表更好。

顺序表的存储空间利用率>链表的存储空间利用率，因为链表结点中的指针域占存储空间。

South.return
关注
专栏目录
JAVA 系列——＞数据结构（栈、队列、数组、链表和红黑树）
JAVA求生之路——博主406766467
01-13 2294
点进来的朋友先点个赞再点个关注好不好，求支持！一直往后更新。 数据结构有什么用？ 当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。 现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还...
Java排序链表
LX__dream的博客
05-28 3022
剑指offer 148.排序链表 解题思路: 由时间复杂度O(nlogn)知道我们可以使用归并排序 归并排序经常会出现在合并两个有序链表这样类似的题中 定义fast指针和slow指针, 利用fast和slow将链表从中点分为两个链表 ① 对应操作: slow = slow.next; fast = fast.next.next; 此时slow指针刚好停在链表的中点 ② 将链表从中间断开的操作: slow.next = null; ③ 此时左右两个断开的链表的第一个节点分别为head和tmp 对.
Java自定义链表
Snowy_2012的博客
03-13 296
链表类package com.link; /** * 链表的增删改查（未处理任何异常） * @author Jing*/ public class JLinkList { LinkNode head; LinkNode current; int size; public JLinkList() { head=current=new LinkNode(null); size=...
Java中的链表
2301_78373304的博客
12-15 688
在前面我们已经学习了关于顺序表ArrayList的一些基本操作。通过源码知道，ArrayList底层使用数组来存储元素，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。
Java数据结构中的链表
最新发布
m0_56186047的博客
12-17 401
链表是一种常见的数据结构，它由一组节点组成，每个节点都包含一个数据元素和一个指向下一个节点的指针。与数组相比，链表具有动态性，可以在运行时灵活地添加、删除和修改节点。本文将介绍链表的来源、使用场景，编写一个链表的示例，并给出使用链表的注意事项。// 头节点// 节点类T data;// 节点数据// 下一个节点链表是一种常见的动态数据结构，通过节点之间的指针关系实现元素的添加、删除和修改。它的灵活性使得它在队列、栈等数据结构的实现以及存储大量数据的场景中发挥重要作用。
Java 实现一个链表
小地盘的诺克萨斯
06-04 1047
public class MyList { static class Node {// 节点类 Object data; Node next; public Node(Object data) {// 构造方法，为data赋值 this.data = data; this.next = null;
数据结构-链式存储结构（单链表）Java实现
master_1997的博客
09-19 1264
在之前学习了线性表的顺序存储结构之后，我们知道顺序存储结构的优点就是查询和修改速度快，但是它也是有缺点的，那就是插入和删除需要移动大量的元素，显然非常的耗费时间，所以我们就需要学习新的知识来解决这个问题，那就是链式存储结构。顺序存储结构的缺点，恰恰就是链式存储结构的优点。 线性表链式存储结构定义 为了表示每个数据元素ai与其直接后继数据元素ai+1 之间的逻辑关系,对数据元素ai来说,除了存储其本...
数据结构之链式表——Java实现
qq_39863593的博客
05-13 952
数据结构之链式表——Java实现 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比...
Java数据结构——循环链表与双向链表
NoBug
12-21 921
1. 循环链表****** 2. 双向链表******
数据结构——栈和队列
qq_51497720的博客
04-23 2347
数据结构——栈和队列 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 数据结构简介 顺序结构 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 链式结构 全新的界面设计 ，将会带来全新的写作体验；## 标题 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高
Java数据结构——HashMap、ConcurrentHashMap
m0_38057941的博客
08-26 329
HashMap的31个问题 1：说说HashMap 底层数据结构是怎样的？ jdk8前：HashMap 底层是 hash 数组和单向链表实现； jdk8后：采用hash数组+链表+红黑树的数据结构。 2：谈一下HashMap的特性？ 我们通过put和get存储和获取对象。 当我们给put()方法传递键和值时：先对键做一个hashCode()的计算，来得到它在bucket数组中的位置来存储Entry对象。 当获取对象时，通过get获取到bucket的位置，再通过键对象的equals()方法找到正确的键值
【数据结构基础】线性数据结构——栈和队列的总结及封装(C和java)
wayne_lee_lwc的博客
10-04 1929
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
Java实现一个链表
4tong的博客
04-20 297
Java实现一个链表 概念 链表是一种物理存储结构上非连续的存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序来实现的。物理上不一定连续，逻辑上一定是连续的。 链表的8种结构 单向、双向 带头、不带头 循环、非循环 无头单向非循环链表的实现 定义一个Node类，来定义链表中的一个节点 class Node { public int val; public Node next; public Node(int val){ this.val = val;
java 自定义一个单向链表
lq774879924的博客
04-27 280
下面展示一些 内联代码片。 package com.javatest; public class MysingleList { //设计一个结点类，结点包括数据和下一个结点的地址 class Node { Object data; Node next; public Node(Object data, Node next) { ...
java定义一个单向链表_Java实现单链表以及链表的基本操作
weixin_39672396的博客
02-27 556
微信公众号：Joyo说链表是基本的数据结构，笔试或者面试的时候也是常常考察的内容，所以实现一个简单的单链表以及对链表的基本操作要学会信手拈来，面试的时候才能临危不惧吧，加油。单链表的结构单链表结构上面展示的是一个单链表的存储原理图，简单易懂，head为头节点，他不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个next引用，指向下一个节点，就这样一节一节往...
Java实现链表
m0_64368538的博客
12-12 3465
新手用Java写链表
Java面向对象编程-链表
qq_50743381的博客
05-06 1076
链表 1、链表的基本定义 链表的本质是一个动态的对象数组 在实际的开发之中对象数组是一项非常实用的技术，并且利用其可以描述出“多”方的概念，例如：一个人有多少本数，则在人的类里面一定要提供有一个对象数组保存书的信息，但是传统的对象数组依赖于数组的概念，所以数组里面最大的缺点在于：长度是固定的，正是因为如此所以在实际开发之中，传统数组应用是非常有限的（数组的接受以及循环处理），但是如果要想进行灵活的数据保存，那么就必须自己来实际结构 传统对象数组的开发操作依赖于脚标（索引）的控制，如果要想实现内容的动态维护，
用Java创建链表
热门推荐
编程小栈
01-28 1万+
前言： java不像C、C++一样可以建立指针来形成链表，创建结构体然后连接成链。java是一门面向对象的程序设计，所以他的基本单位是类。 思路： 仍然是建立建立类，这里用到了内部类。 建立一个类为Link，在其中建立一个内部类。 link可以使用add方法来添加节点，使用print来打印。 package zx; class Link{ private Node root;
SuperJava|定义一个链表结构并进行数据插入
RikLiOnline
08-21 341
@[FAT-Remcal|Coding诗酒醉年华] SuperJava|定义一个链表结构并进行数据插入 知识要点 （链表的知识要点在上一篇blog中已经介绍，此处略过，直接上代码，注意看注释部分） Code： /** 功能描述：请自己定义一个链表结构，并进行数值插入（form "m" to "n"）,"m"与"n"分别从键盘录入； */ import java.util.Scanner; publ...
Java数据结构：链表定义与实现详解
"lue要插入的数据 */ publicvoidinsert(longvalue){ Node newNode=new Node(value);...这篇教程为初学者提供了理解Java中链表数据结构及其实现的基础知识，有助于进一步学习和掌握数据结构和算法。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

South.return

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

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

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

打赏作者

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

抵扣说明：

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

余额充值