数据结构--单链表--(Java)

最新推荐文章于 2023-04-21 23:37:40 发布
最新推荐文章于 2023-04-21 23:37:40 发布
阅读量454 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46636892/article/details/126735035
版权

单链表概念及结构

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
链表中的数据是以结点来表示的，每个节点又分为数据data和下一节点的next引用

在这里插入图片描述

ListNode{
	value=111, 
	next=ListNode{
			value=222, 
			next=ListNode{
					value=333, 
					next=ListNode{
							value=444, 
							next=ListNode{	
									value=555, 
									next=null
									}
							}
					}
			}
	}

Node节点

public class Node {

    private int value;
    private Node next;

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

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public Node getNext() {
        return next;
    }

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

    @Override
    public String toString() {
        return "ListNode{" +
                "value=" + value +
                ", next=" + next +
                '}';
    }
}

单链表接口方法


public interface LinkList {
    
    //头插法
    public void insertHead(int value);

    //任意插
    public void insert(int n,int value);

    //尾插法
    public void insertTail( int value);

    //更新元素
    public void update(int value,int newValue);

    //删除元素
    public void remove(int value);

    //判断是否含有
    public boolean contains(int value);

    //单链表长度
    public int size();

    //打印
    public void display();

    //清理
    public void clear();

}

接口方法的实现

链表初始化
	public class IList implements LinkList{
	
	    private Node head;		//头结点
	    private int size;		//链表长度


		/**
		 *	链表实现的具体方法
		 */
	}
头插法-insertHead
    @Override
    public void insertHead(int value) {
        if (head==null){
            head = new Node();
            head.setValue(value);
            size++;
            return;
        }
        Node node = new Node(value);
        node.setNext(head);
        this.head=node;
        size++;
    }
任意插-insert
    @Override
    public void insert(int n,int value) {
        if (n<0 || n>size){
            System.out.println("插入数据索引 "+n+" 不合法！");
            return;
        }
        if (n==0){
            insertHead(value);
            return;
        }
        if (n==size){
            insertTail(value);
            return;
        }
        Node newNode = new Node(value);
        Node node = head;
        for (int index=1;index<=n;index++){
            if (index==n){
                newNode.setNext(node.getNext());
                node.setNext(newNode);
                size++;
            }
            node=node.getNext();
        }

    }
尾插法-insertTail
    @Override
    public void insertTail( int value) {
        if (head==null){
            head = new Node();
            head.setValue(value);
            size++;
            return;
        }
        Node node = head;
        while(node.getNext()!=null){
            node=node.getNext();
        }
        Node nodeTail = new Node(value);
        node.setNext(nodeTail);
        size++;
    }
节点更新-update
    @Override
    public void update(int value,int newValue) {
        Node node=head;
        for (int count=0;count<size;count++){
            if (node.getValue()==value){
                node.setValue(newValue);
                System.out.println(String.format("您需要更新的元素%s已更新",value));
                return;
            }
            node=node.getNext();
        }
        System.out.println(String.format("您需要更新的元素%s不存在",value));
    }
节点删除-remove
    @Override
    public void remove(int value) {
        if (head.getValue()==value){
            head=head.getNext();
            size--;
            System.out.println(String.format("已删除元素%s",value));
            return;
        }
        Node node=head;
        for (int count=1;count<size;count++){
            if (node.getNext().getValue()==value){
                node.setNext(node.getNext().getNext());
                size--;
                System.out.println(String.format("已删除元素%s",value));
                return;
            }
            node=node.getNext();
        }
        System.out.println(String.format("您需要删除的元素%s不存在",value));
    }
判断节点是否存在-contains
    @Override
    public boolean contains(int value) {
        Node node=head;
        for (int count=0 ;count<size;count++){
            if (node.getValue()==value){
                return true;
            }
            node=node.getNext();
        }
        return false;
    }
链表长度-size
    @Override
    public int size() {
        return size;
    }
链表打印-display
    @Override
    public void display() {
        Node node=head;
        if (node==null){
            System.out.println("当前单链表为空!");
        }
        for (int count=0;count<size;count++){
            System.out.println(node.getValue()+"-->"+node.getNext());
            node=node.getNext();
        }
    }
链表清理-clear
    @Override
    public void clear() {
        this.head=null;
        this.size=0;
    }

Demo演示

public class Demo {

    public static void main(String[] args) {
        IList iList = new IList();
        iList.insertTail(111);
        iList.insert(1,222);
        iList.insert(2,333);
        iList.insert(3,444);
        iList.insertTail(555);
        iList.display();
        System.out.println("当前单链表长度为："+iList.size());

        iList.insertHead(666);
        iList.insert(0,777);
        iList.insertHead(888);
        iList.display();
        System.out.println("当前单链表长度为："+iList.size());
        iList.insert(3,999);
        iList.insert(4,1010);
        iList.insert(111,111);
        System.out.println("当前单链表长度为："+iList.size());
        iList.display();
        System.out.println("==========contains==========");
        System.out.println("1010存在于单链表中吗？ " + iList.contains(1010));
        System.out.println("10存在于单链表中吗？ " + iList.contains(10));
        System.out.println("111存在于单链表中吗？ " + iList.contains(111));
        System.out.println("==========update==========");
        iList.update(1010,1011);
        iList.update(9090,1111);
        System.out.println("当前单链表长度为："+iList.size());
        iList.display();
        System.out.println("==========remove==========");
        iList.remove(888);
        iList.remove(555);
        iList.remove(1011);
        iList.remove(1010);
        System.out.println("当前单链表长度为："+iList.size());
        iList.display();
        System.out.println("==========clear==========");
        iList.clear();
        System.out.println("当前单链表长度为："+iList.size());
        iList.display();
    }
}

结果


111-->ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}
222-->ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}
333-->ListNode{value=444, next=ListNode{value=555, next=null}}
444-->ListNode{value=555, next=null}
555-->null
当前单链表长度为：5
888-->ListNode{value=777, next=ListNode{value=666, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}
777-->ListNode{value=666, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}
666-->ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}
111-->ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}
222-->ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}
333-->ListNode{value=444, next=ListNode{value=555, next=null}}
444-->ListNode{value=555, next=null}
555-->null
当前单链表长度为：8
插入数据索引 111 不合法！
当前单链表长度为：10
888-->ListNode{value=777, next=ListNode{value=666, next=ListNode{value=999, next=ListNode{value=1010, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}}}
777-->ListNode{value=666, next=ListNode{value=999, next=ListNode{value=1010, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}}
666-->ListNode{value=999, next=ListNode{value=1010, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}
999-->ListNode{value=1010, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}
1010-->ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}
111-->ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}
222-->ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}
333-->ListNode{value=444, next=ListNode{value=555, next=null}}
444-->ListNode{value=555, next=null}
555-->null
==========contains==========
1010存在于单链表中吗？ true
10存在于单链表中吗？ false
111存在于单链表中吗？ true
==========update==========
您需要更新的元素1010已更新
您需要更新的元素9090不存在
当前单链表长度为：10
888-->ListNode{value=777, next=ListNode{value=666, next=ListNode{value=999, next=ListNode{value=1011, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}}}
777-->ListNode{value=666, next=ListNode{value=999, next=ListNode{value=1011, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}}
666-->ListNode{value=999, next=ListNode{value=1011, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}}
999-->ListNode{value=1011, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}}
1011-->ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}}
111-->ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}}
222-->ListNode{value=333, next=ListNode{value=444, next=ListNode{value=555, next=null}}}
333-->ListNode{value=444, next=ListNode{value=555, next=null}}
444-->ListNode{value=555, next=null}
555-->null
==========remove==========
已删除元素888
已删除元素555
已删除元素1011
您需要删除的元素1010不存在
当前单链表长度为：7
777-->ListNode{value=666, next=ListNode{value=999, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=null}}}}}}
666-->ListNode{value=999, next=ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=null}}}}}
999-->ListNode{value=111, next=ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=null}}}}
111-->ListNode{value=222, next=ListNode{value=333, next=ListNode{value=444, next=null}}}
222-->ListNode{value=333, next=ListNode{value=444, next=null}}
333-->ListNode{value=444, next=null}
444-->null
==========clear==========
当前单链表长度为：0
当前单链表为空!

Process finished with exit code 0

链表和线性表都是为了存储数据而设计的数据结构，只不过线性表查询快，链表增删快。线性表物理存储单元上是连续的，长度固定且使用时可能需要动态扩容。链表由一系列节点组成，节点可以在运行时动态生成，链表长度不固定。

陈大大的期待
关注
专栏目录
数据结构---链表（java实现）
Enl0ve的博客
07-02 8766
近来越来越感觉数据结构和算法的重要性，于是决定花时间整理一下数据结构，一来希望自己能够更加深刻地理解数据结构，二来也希望和大家认真分享一下自己的理解，希望能够一起学习，一起进步，开心每一天。今天先复习一下数据结构中比较常见的链表。本文以图示方法和代码演示详细地对链表及相关演变的链表做一个详细的讲解。希望看到这边文章的各位博友能够评论一下，哪怕是发个“已读”也好，感觉这样才有讨论的学习氛围。单链表这...
王道考研数据结构之------单链表操作(不带头结点)
liquid_road的博客
08-20 496
链接： 王道2021数据结构链接 提取码：rpy8 –来自百度网盘超级会员V4的分享` typedef int ElemType;//元素的类型 typedef int ElemType;//元素的类型 typedef struct LNode { ElemType data; LNode* next; }LNode,*LinkList; /*--------------------------------*/ //初始化单链表 void InitList(LinkList &L){ //
JAVA数据结构单链表
qq_39804990的博客
05-13 234
单链表的使用 增删改查
Java数据结构之单链表
小白轩的博客
06-03 1605
一、单链表的概念 1、链表是最基本的数据结构，其存储的过程原理图如下图所示： 1.2、上面展示的是一个单链表的存储原理图，简单易懂，head为头节点，他不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个next引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，其中的next指向null。 链表有很多种，比如单链表，双链表等等。我们就对单链...
Java数据结构之单链表（配图详解，简单易懂）
如风暖阳的博客
01-17 4142
Java数据结构之单链表（配图详解，简单易懂）
java数据结构：单链表结构与实现
cetrol_chen的博客
01-26 472
本教程的内容基本来自于《Java数据结构与算法》 单向链表是最基本的数据结构之一，链表中的基本单位是节点，节点包含数据和其他节点的指针。不同于数组的是，链表中的数据存储地址在物理上不是连续的，而是使用指针来指向下一节点。 每个节点有数据区（data）和指向下一节点的指针（next），当next指针指向null时，表示链表的尾节点。 单个节点定义 class Link{ pu
数据结构-链式存储结构（单链表）Java实现
master_1997的博客
09-19 1281
在之前学习了线性表的顺序存储结构之后，我们知道顺序存储结构的优点就是查询和修改速度快，但是它也是有缺点的，那就是插入和删除需要移动大量的元素，显然非常的耗费时间，所以我们就需要学习新的知识来解决这个问题，那就是链式存储结构。顺序存储结构的缺点，恰恰就是链式存储结构的优点。 线性表链式存储结构定义 为了表示每个数据元素ai与其直接后继数据元素ai+1 之间的逻辑关系,对数据元素ai来说,除了存储其本...
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
最新发布
03-03
在Java面试中，数据结构是不可或缺的一个重要环节，因为它直接影响到程序的效率和设计质量。本资料包"面试-Java一些常见面试题+题解之数据结构-DataStructure.zip"聚焦于Java中的数据结构，旨在帮助求职者更好地准备...
漫话数据结构-单链表的基本操作.pptx
11-03
单链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一个节点的引用。在单链表中，数据的访问和操作主要依赖于这些节点间的链接关系。本讲主要讨论了单链表的四个基本操作：求表的长度、...
数据结构-不带头结点的单链表创建（头插法+尾插法），插入，删除
weixin_56653375的博客
03-23 559
无头结点的单链表创建
Java实现单链表数据结构
xuyao12580的专栏
03-31 934
这两天翻了下大二学习的数据结构教材，因为是C++版的，看完线性表的连接存储结构—单链表，用C++实现不是很难。因为学习了java，所以就思考着如何用java实现单链表。但是C++使用的是指针，而Java实际上没有指针，但是Java有引用，实际上能用Java模拟实现单链表，而且个人感觉比C++还容易实现些。 c++使用的是结构体模拟结点，Java这里使用类模拟了一个结点。为方便访问数据域权限全部公有
单链表结构（JAVA）
Artisan_w
03-09 159
单链表的存储结构 数据域 指针域 数据域用来存储数据元素的值，指针域（或称为链）用来存储元素的直接后驱。 程序定义： public class ListNode { public int val; public ListNode next; public ListNode(int x) { val = x; } } 其中val代表数据，next代表链表的直接...
数据结构——单链表的Java实现
chenshiyang0806的博客
05-30 352
以前我只是单纯用数组，数组它有固定的长度，是有缺点的，不能随意改变它的长度，而链表可以插入和删除大量元素。 接下来我来介绍下单链表 什么是单链表呢 链表的每个结点中只包含一个指针域，叫做单链表（即构成链表的每个结点只有一个指向直接后继结点的指针，且尾节点的指针为null）。 结点结构如下： 接下来呢，我举一个简单的存储整数的单链表的列子 一.存储整数的单链表分为三部分 1.结点 2...
Java数据结构--单链表
m0_74808313的博客
04-21 1424
我们在实现单向链表之前，先了解一下Java API中LinkedList类的方法摘要，并学会如何去创建使用链表，熟练运用其中常用的几种方法(增删差)下面为LinkedList类中的所有方法摘要看到这么多方法，是不是头都大了，但不要慌，我们只需熟练掌握其中最常用的几种方法即可，其余的只需了解。下面我们来运行一下其中最常用的几种方法(我们要实现的也是以下主要方法)addFirst(元素) 将指定元素添加到链表开头add(元素)将指定元素添加到链表结尾。
数据结构之单链表（java版）
qq_42489613的博客
10-23 1501
数据结构就是用某种结构去储存数据
数据结构-单链表(Java实现)
weixin_51951233的博客
09-07 162
单链表 一种链式存储的数据结构,链表中的数据是由元素+指针构成,从头结点开始依次指向后面的每一位 ​ 可以在内存中就直接能够排序数据 ​ 比如在业务中,如果给你一堆无序id的数据,就可以直接用单例表中的有序排列让数据按顺序排起来 package singlelinkedlist; /* @CreateTime 2021/9/6 10:44 @CreateBy cfk */ public class SingleLinkedListDemo { public
java数据结构（一）单链表
qq_50438796的博客
03-09 452
java数据结构（一） 单链表 单链表是一种线性存储结构，其逻辑上相邻的存储单元物理上不一定相邻。 利用单链表模拟一个简易英雄人物管理系统。其中英雄人数包含的属性如下： 1）编号 2）姓名 3）昵称。 编号为主码。 实现数据的增删改查。并在增删时分别模拟了链头增，链尾增，链头删，链尾删的功能。其中的链尾增和链尾删结合可以模拟栈；链尾增和链头删可以模拟队列。 具体代码如下： package com.yck.linkedlist; import java.util.Scanner; public class
数据结构之单链表（java实现）
qq_44541541的博客
10-14 254
数据结构之单链表（java实现） 单链表是一种查询满增删快的数据结构。本文实现了数据结构中单链表结构。实现了单链表中的添加、读取、插入、删除和打印常见操作。 代码： 结点类： public class Node {//创建Node类，成员变量包含数据和next node； public Object data; public Node next = null; public Node(Object data){ this.data = data; } }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值