java实现单链表NodeList

最新推荐文章于 2023-09-21 22:30:14 发布
最新推荐文章于 2023-09-21 22:30:14 发布
阅读量1.4k 收藏 13
点赞数 2
文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quarkx/article/details/127909950
版权

目录

一、单链表的概念

二、单链表的实现

1.定义节点类

2.定义单链表

1.属性

2.方法

三、完整实现

一、单链表的概念

单链表的概念：单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。

具体而言

单链表由头结点和元素结点连接组成。

单链表的每个结点由数据域和指针域组成。数据域存储数据，指针域存储下一个结点的地址。

https://www.dotcpp.com/oj/ueditor/php/upload/image/20190618/1560862606257333.png

 

单链表的最后一个结点的指针域指向空（NULL）。

头结点的作用：

统一操作--由于开始结点的位置被存放在头结点的指针域中，所以在链表的第一个位置上的操作和其他位置的结点的操作一样，无需做其他特殊处理。
统一判空--链表为空时，头结点的指针域指向空，即可判空，链表不为空时，头结点的指针域指向第一个元素结点，头结点的指针域不为空，即可判不空。

 

二、单链表的实现

1.定义节点类

package com.zsj1105;

public class Node<E> {
    public E value;   //存储结点的值
    public Node next;   //用来存储下一个结点的地址

    //空参构造方法
    public Node(){

    }

    //有参构造方法
    public Node(E value,Node next){
        //每个结点都有一个数据域和地址域
        this.value = value;
        this.next = next;

    }

}

2.定义单链表

1.属性

* head 头部结点

* tail 尾部结点

* curr 当前结点

* size 元素个数

    //属性
    private Node<E> head;  //设置头部结点
    private Node<E> tail;  //设置尾部结点
    private Node<E> curr;  //设置当前结点
    private int size;  //设置元素个数

2.方法

（1）构造方法

* 1.NodeList() 空参数构造方法
* 2.NodeList(Node node) 由一个结点创建一个链表

 //构造方法

    /**
     * 无参数构造方法
     */
    NodeList() {
        head = tail = curr = new Node();
        size = 0;
    }

    /**
     * 由一个结点创建链表
     *
     * @param node
     */
    NodeList(Node node) {
        head = tail = curr = new Node();
        this.size = 1;
        this.head.next = node;
        this.tail = node;
    }

（2）方法

* 1.int getSize() 获取总元素个数
* 2.Node getHead() 获取头部结点
* 3.Node getCurr() 获取当前结点
* 4.Node getTail() 获取尾部结点
* 5.void setCurr() 设置当前结点
* 6.void print() 打印链表中的所有元素
* 7.void addToHead(E value)在头部结点后面插入结点
* 8.void addToTail(E value)在尾部结点后面插入结点
* 9.void insert(E value)将当前结点值设为value
* 10.delete()删除当前结点之后的一个结点
* 11.delete(E value)删除第一个值为value的结点
* 12.find(E value)找到值为value的结点
* 13.replace(E value)将当前结点的值替换为value
* 14.replace(E value1, E value2)将值为value1的结点的值替换为value2

  //方法

    /**
     * 获取元素个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 获取头部结点
     *
     * @return
     */
    public Node<E> getHead() {
        return head;
    }

    /**
     * 获取当前结点
     *
     * @return
     */
    public Node<E> getCurr() {
        return curr;
    }

    /**
     * 获取尾部结点
     *
     * @return
     */
    public Node<E> getTail() {
        return tail;
    }

    /**
     * 设置当前结点为指定结点
     *
     * @param curr
     */
    public void setCurr(Node curr) {
        this.curr = curr;
    }

    /**
     * 打印出链表中的所有元素
     */
    public void print() {
        if (size == 0)
            System.out.println("链表中没有元素");
        else {
            this.curr = this.head.next;
            System.out.print("单链表中的元素:head-");
            while (this.curr != null) {
                System.out.print(this.curr.value + "-");
                this.curr = this.curr.next;
            }
            System.out.println("null");
            System.out.println("元素个数" + this.size);
        }
    }

    /**
     * 在头部结点之后插入结点
     *
     * @param value
     */
    public void addToHead(E value) {
        if (size == 0) {
            this.tail = new Node(value, null);
            this.head.next = this.tail;
        } else
            this.head.next = new Node(value, this.head.next);
        size++;
    }

    /**
     * 在尾部结点之后插入结点
     *
     * @param value
     */
    public void addToTail(E value) {
        if (size == 0) {
            this.tail = new Node(value, null);
            this.head.next = this.tail;
        } else {
            this.tail.next = new Node(value, null);
            this.tail = this.tail.next;
        }
        size++;
    }

    /**
     * 在当前结点后面插入结点
     *
     * @param value
     */
    public void insert(E value) {
        if (this.curr == this.head) {
            addToHead(value);
        } else if (this.curr == this.tail) {
            this.curr.next = new Node(value, null);
            this.tail = this.curr.next;
            size++;
        } else {
            this.curr.next = new Node(value, this.curr.next);
            size++;
        }

    }


    /**
     * 删除当前结点之后的一个结点
     */
    public void delete() {
        if (this.curr == this.tail) {
            System.out.println("超出范围");
        } else if (size == 0) {
            System.out.println("链表中没有元素");
        } else if (this.curr.next == this.tail) {
            this.curr.next = null;
            this.tail = this.curr;
            size--;
            System.out.println("删除成功");
        } else {
            this.curr.next = this.curr.next.next;
            size--;
            System.out.println("删除成功");
        }

    }

    /**
     * 删除值为value的结点
     *
     * @param value
     */
    public void delete(E value) {
        int count = 0;
        if (size == 0) {
            System.out.println("链表中没有元素");
        } else if (size == 1) {
            if (this.tail.value.equals(value)) {
                this.head.next = null;
                this.tail = this.head;
                size--;
            }
        } else {
            this.curr = this.head;
            while (this.curr.next != null) {
                if (this.curr.next.value.equals(value)) {
                    if (this.curr.next.next == null) {
                        this.curr.next = null;
                    } else {
                        this.curr.next = this.curr.next.next;
                    }
                    size--;
                    count++;
                    System.out.println("删除成功");
                    continue;
                }
                this.curr = this.curr.next;
            }

            System.out.println("一共删除了" + count + "个结点");
        }
    }

    /**
     * 返回第一个值为value的结点或者boolean
     *
     * @param value
     * @return
     */
    public Node find(E value) {
        if (size == 0) {
            System.out.println("链表中无元素");
            return null;
        }
        this.curr = this.head.next;
        while (this.curr != null) {
            if (this.curr.value.equals(value)) {
                return this.curr;
            }
            this.curr = this.curr.next;
        }
        System.out.println("链表中没有这个元素");
        return null;
    }

    /**
     * 将当前结点的值替换为value
     *
     * @param value
     */
    public void replace(E value) {
        if (size == 0) {
            System.out.println("链表中没有元素");
        }
        if (this.curr == this.head) {
            System.out.println("当前位置(在头部结点)不合法");
        }
        this.curr.value = value;

    }

    /**
     * 将所有value1替换为value2
     *
     * @param value1
     * @param value2
     */
    public void replace(E value1, E value2) {
        int count = 0;
        if (size == 0) {
            System.out.println("链表中没有元素");
        }
        this.curr = this.head.next;
        while (this.curr != null) {
            if (this.curr.value.equals(value1)) {
                this.curr.value = value2;
                count++;
            }
            this.curr = this.curr.next;
        }
        System.out.println("一共完成了" + count + "次替换");

三、完整实现

package com.zsj1105;

import javax.swing.*;

/**
 * NodeList 链表类，结点串联(首结点不存元素)
 * 一、属性
 * 1.head 头部结点
 * 2.tail 尾部结点
 * 3.curr 当前结点
 * 4.size 元素个数
 * <p>
 * 二、构造方法
 * 1.NodeList() 空参数构造方法
 * 2.NodeList(Node node) 由一个结点创建一个链表
 * <p>
 * 三、方法
 * 1.int getSize() 获取总元素个数
 * 2.Node getHead() 获取头部结点
 * 3.Node getCurr() 获取当前结点
 * 4.Node getTail() 获取尾部结点
 * 5.void setCurr() 设置当前结点
 * 6.void print() 打印链表中的所有元素
 * 7.void addToHead(E value)在头部结点后面插入结点
 * 8.void addToTail(E value)在尾部结点后面插入结点
 * 9.void insert(E value)将当前结点值设为value
 * 10.delete()删除当前结点之后的一个结点
 * 11.delete(E value)删除第一个值为value的结点
 * 12.find(E value)找到值为value的结点
 * 13.replace(E value)将当前结点的值替换为value
 * 14.replace(E value1, E value2)将值为value1的结点的值替换为value2
 */
public class NodeList<E> {
    //属性
    private Node<E> head;  //设置头部结点
    private Node<E> tail;  //设置尾部结点
    private Node<E> curr;  //设置当前结点
    private int size;  //设置元素个数

    //构造方法

    /**
     * 无参数构造方法
     */
    NodeList() {
        head = tail = curr = new Node();
        size = 0;
    }

    /**
     * 由一个结点创建链表
     *
     * @param node
     */
    NodeList(Node node) {
        head = tail = curr = new Node();
        this.size = 1;
        this.head.next = node;
        this.tail = node;
    }

    //方法

    /**
     * 获取元素个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 获取头部结点
     *
     * @return
     */
    public Node<E> getHead() {
        return head;
    }

    /**
     * 获取当前结点
     *
     * @return
     */
    public Node<E> getCurr() {
        return curr;
    }

    /**
     * 获取尾部结点
     *
     * @return
     */
    public Node<E> getTail() {
        return tail;
    }

    /**
     * 设置当前结点为指定结点
     *
     * @param curr
     */
    public void setCurr(Node curr) {
        this.curr = curr;
    }

    /**
     * 打印出链表中的所有元素
     */
    public void print() {
        if (size == 0)
            System.out.println("链表中没有元素");
        else {
            this.curr = this.head.next;
            System.out.print("单链表中的元素:head-");
            while (this.curr != null) {
                System.out.print(this.curr.value + "-");
                this.curr = this.curr.next;
            }
            System.out.println("null");
            System.out.println("元素个数" + this.size);
        }
    }

    /**
     * 在头部结点之后插入结点
     *
     * @param value
     */
    public void addToHead(E value) {
        if (size == 0) {
            this.tail = new Node(value, null);
            this.head.next = this.tail;
        } else
            this.head.next = new Node(value, this.head.next);
        size++;
    }

    /**
     * 在尾部结点之后插入结点
     *
     * @param value
     */
    public void addToTail(E value) {
        if (size == 0) {
            this.tail = new Node(value, null);
            this.head.next = this.tail;
        } else {
            this.tail.next = new Node(value, null);
            this.tail = this.tail.next;
        }
        size++;
    }

    /**
     * 在当前结点后面插入结点
     *
     * @param value
     */
    public void insert(E value) {
        if (this.curr == this.head) {
            addToHead(value);
        } else if (this.curr == this.tail) {
            this.curr.next = new Node(value, null);
            this.tail = this.curr.next;
            size++;
        } else {
            this.curr.next = new Node(value, this.curr.next);
            size++;
        }

    }


    /**
     * 删除当前结点之后的一个结点
     */
    public void delete() {
        if (this.curr == this.tail) {
            System.out.println("超出范围");
        } else if (size == 0) {
            System.out.println("链表中没有元素");
        } else if (this.curr.next == this.tail) {
            this.curr.next = null;
            this.tail = this.curr;
            size--;
            System.out.println("删除成功");
        } else {
            this.curr.next = this.curr.next.next;
            size--;
            System.out.println("删除成功");
        }

    }

    /**
     * 删除值为value的结点
     *
     * @param value
     */
    public void delete(E value) {
        int count = 0;
        if (size == 0) {
            System.out.println("链表中没有元素");
        } else if (size == 1) {
            if (this.tail.value.equals(value)) {
                this.head.next = null;
                this.tail = this.head;
                size--;
            }
        } else {
            this.curr = this.head;
            while (this.curr.next != null) {
                if (this.curr.next.value.equals(value)) {
                    if (this.curr.next.next == null) {
                        this.curr.next = null;
                    } else {
                        this.curr.next = this.curr.next.next;
                    }
                    size--;
                    count++;
                    System.out.println("删除成功");
                    continue;
                }
                this.curr = this.curr.next;
            }

            System.out.println("一共删除了" + count + "个结点");
        }
    }

    /**
     * 返回第一个值为value的结点或者boolean
     *
     * @param value
     * @return
     */
    public Node find(E value) {
        if (size == 0) {
            System.out.println("链表中无元素");
            return null;
        }
        this.curr = this.head.next;
        while (this.curr != null) {
            if (this.curr.value.equals(value)) {
                return this.curr;
            }
            this.curr = this.curr.next;
        }
        System.out.println("链表中没有这个元素");
        return null;
    }

    /**
     * 将当前结点的值替换为value
     *
     * @param value
     */
    public void replace(E value) {
        if (size == 0) {
            System.out.println("链表中没有元素");
        }
        if (this.curr == this.head) {
            System.out.println("当前位置(在头部结点)不合法");
        }
        this.curr.value = value;

    }

    /**
     * 将所有value1替换为value2
     *
     * @param value1
     * @param value2
     */
    public void replace(E value1, E value2) {
        int count = 0;
        if (size == 0) {
            System.out.println("链表中没有元素");
        }
        this.curr = this.head.next;
        while (this.curr != null) {
            if (this.curr.value.equals(value1)) {
                this.curr.value = value2;
                count++;
            }
            this.curr = this.curr.next;
        }
        System.out.println("一共完成了" + count + "次替换");
    }

    public static void main(String[] args) {
        NodeList<Integer> nodeList = new NodeList<Integer>(new Node<Integer>(520, null));
//        for (int i = 0; i < 20; i++) {
//            nodeList.addToHead(i);
//            nodeList.print();
//        }
//        System.out.println(nodeList.size);
//        System.out.println(nodeList.getTail().value);
//        for (int i = 0; i < 20; i++) {
//            nodeList.addToTail(i);
//            nodeList.print();
//        }

//        nodeList.addToHead(5);
//        System.out.println(nodeList.size);
//        nodeList.addToHead(250);
//        System.out.println(nodeList.size);
//        nodeList.addToHead(270);
//        System.out.println(nodeList.size);
//        nodeList.delete(520);
//        nodeList.print();

        for (int i = 0; i < 5; i++) {
            nodeList.addToHead(i);
        }
//        nodeList.print();
//        nodeList.delete(0);
//        nodeList.print();
        nodeList.delete(520);

    }
}

山本二郎
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java实现数据结构单链表示例(java单链表)
09-04
在这个实例中，我们将详细讨论如何使用Java实现单链表。 1. **单链表节点类(Node)**： - `Node` 类内部定义了两个属性：`data` 和 `next`。 - `data` 用于存储节点的元素，可以是任意类型（通过泛型 <E> 表示）。...
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3342
数据结构之单链表的实现
Java实现单链表（步骤详解+源码）
GSCY
10-14 7001
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
数据结构之单链表（java版）
qq_42489613的博客
10-23 1410
数据结构就是用某种结构去储存数据
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1968
单链表增删改查，排序，反转，倒序打印，两条单链表合并
Java单链表
weixin_73000974的博客
07-15 662
什么是链表链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。链表概念及特点头指针：是指向链表中第一个结点的指针首元结点：是指链表中存储的第一个数据元素的结点。
Java实现简单树结构
08-31
本篇将详细讲解如何使用Java实现一个简单的树结构，包括树节点类`treeNode`、树类`tree`以及相关的操作方法。 首先，我们来看`treeNode`类的实现。`treeNode`代表树中的一个节点，它可以存储任意类型的数据，这里用...
Python单链表简单实现代码
09-21
#### 三、Python单链表实现 下面我们将通过具体的Python代码来实现单链表。 ##### 1. 节点类(Node) ```python class Node(object): def __init__(self, data): self.data = data self.next = None ``` **解释**...
原生JS实现循环Nodelist Dom列表的4种方式示例
10-18
如果你希望Nodelist对象本身就具有`forEach`方法，可以通过扩展Nodelist.prototype来实现。这种方法需要注意可能会与其他库或代码冲突，因此在实际项目中要谨慎使用。 ```javascript NodeList.prototype.forEach = ...
java实现简单解析XML文件功能示例
08-29
Java实现简单解析XML文件功能示例 Java语言是目前最流行的编程语言之一，广泛应用于移动应用、Web应用、企业软件等领域。XML（Extensible Markup Language）是一种常用的数据交换格式，广泛应用于数据交换、配置...
单链表的创建---java
weixin_45721847的博客
03-28 1541
【代码】单链表的创建---java。
java nodelist.item,使用NodeList遍历XML中的所有元素
weixin_29103027的博客
02-16 983
I want to loop through all elements in a piece of XML printing each one. My problem is that I keep getting a null pointer exception after the staff1 tag, i.e. john 465456433 gmail1 area1 city1This my...
数据结构-单链表（Java实现，通俗易懂）
m0_62468521的博客
12-08 1193
单链表（Java实现，通俗易懂）
Java数据结构--单链表
m0_74808313的博客
04-21 1345
我们在实现单向链表之前，先了解一下Java API中LinkedList类的方法摘要，并学会如何去创建使用链表，熟练运用其中常用的几种方法(增删差)下面为LinkedList类中的所有方法摘要看到这么多方法，是不是头都大了，但不要慌，我们只需熟练掌握其中最常用的几种方法即可，其余的只需了解。下面我们来运行一下其中最常用的几种方法(我们要实现的也是以下主要方法)addFirst(元素) 将指定元素添加到链表开头add(元素)将指定元素添加到链表结尾。
Java实现单链表
最新发布
2301_76161469的博客
09-21 776
要创建链表首先要有节点，我们可以将节点定义为内部类//存放当前结点的值//存放下一节点的地址由于链表是通过前一个节点访问下一个节点的，因此我们需要知道链表的第一个节点，因此我们需要定义一个头节点//第一个节点。
Java 单链表知识点总结及代码实现
路先生的杂货铺，学习总结+好文分享
09-27 780
JAVA实现单链表 本文通过JAVA实现单链表的基本功能 实现功能 单链表的： 头部增加、头部删除 尾部增加、尾部删除 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示； 全新的 KaTeX数学公式 语法； 增加了支持甘特图的mermaid语法1 功能； 增加了 多屏幕编辑 Markdown文章功能； 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能...
cmscp实例笔记
weixin_33997389的博客
03-24 365
1、迭代循环 [@NodeList;list] [#list list as node] [#if node.name == "产品试用"] [/#if] [#if node.name == "联系我们"] <li class="l3"><a href="${node.url}">${node.name}<...
单链表 — Java
m0_54344602的博客
08-02 582
单链表是一种链式存取的数据结构，单链表虽然不能像顺序表那样实现随机存取，但单链表可以实现在任意位置插入或删除，不需要像顺序表那样需要移动大量元素才能完成，且单链表的地址是随机的，不一定是一段连续的空间...
用java8 实现 NodeList 集合 filter 获取只有一个 元素如何写 ？
06-03
可以使用 Java 8 的 Stream API 来实现 NodeList 集合的筛选操作。具体实现代码如下： ```java NodeList nodeList = ...; // 获取 NodeList 对象 NodeList filteredList = IntStream.range(0, nodeList.getLength...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值