Java-单向链表实现

于 2024-09-06 19:56:12 发布
阅读量716 收藏 11
点赞数 22
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 java 单向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Broken_x/article/details/141963194
版权

什么是链表？

        链表是一种常见的数据结构，用于存储一系列元素。与数组不同，链表中的元素（节点）在内存中不必是连续的。每个节点包含数据部分和指向下一个节点的引用（指针）。链表的主要优点是插入和删除操作的时间复杂度为O(1)，但访问特定元素的时间复杂度为O(n)。

头节点

        在单链表的数据结构中，头节点并不是一个独立的节点，而是一个指针或引用，指向链表中第一个数据节点。它的作用是标记链表的起始位置，以便能够遍历和操作链表中的所有节点。在大多数的单链表实现中，“头节点”本身并没有特别之处，它仅仅是一个指向第一个有效节点的引用。

什么是哨兵节点？

        哨兵节点（也称为哑节点或伪节点）是一个特殊的节点，通常不包含实际数据，仅用于简化链表的操作。在单向链表中，哨兵节点通常作为头节点使用，使得链表的插入、删除等操作更加统一和简单。

代码实现： 

没有将头节点设置为哨兵节点，以下是单向链表的Java实现代码，并解释了关键部分：

package school.singlelinkedlist;

import java.util.Iterator;
import java.util.function.Consumer;

/**
 * 文件名: null.java
 * 作者: 20526
 * 创建时间: 2024/9/6 15:17
 * 描述:单向链表实现
 */
public class SingleLinkedList implements Iterable<Integer>{

    private Node head = null; // 头节点

    //节点类
    public static class Node {
        int data;
        Node next;

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

    }


    //链表遍历
    public void traverse(Consumer <Integer> consumer) {
        Node current = head;//定义一个指针，进行遍历，默认指向头节点

        while (current!= null) {
            consumer.accept(current.data);//调用consumer.accept(data)方法，对当前节点的数据进行处理
            current = current.next;//指针向后移动
        }
    }
    public void traverse2(Consumer <Integer> consumer){
        for (Node current = head; current!= null; current = current.next){
            consumer.accept(current.data);
        }
    }

    //实现迭代器，可以用增强for循环遍历
    @Override
    public Iterator<Integer> iterator() {
        //匿名内部类
        return new Iterator<Integer>() {
            Node current  = head;
            @Override
            public boolean hasNext() { //判断是否有下一个节点
                return current!= null;
            }

            @Override
            public Integer next() { //返回当前值，并指向下一个节点

                int value = current.data;
                current = current.next;
                return value;
            }
        };

    }

    //添加节点到链表头
    public void addfirst(int data) {
//      head = new Node(data, null);
        head = new Node(data, head);

    }

    //查找链表尾节点
    private Node findlast(){
        Node p ;
        if (head == null)
            return null;

        for (p = head; p.next!= null; p = p.next){

        }
        return p;
    }

    //添加节点到链表尾
    public void addlast(int data){
        Node last = findlast();
        if (last == null) {
            addfirst(data);
            return;
        }
        else{
            last.next = new Node(data, null);
        }

    }

    //根据索引插入节点
    public void add(int index, int data) throws IllegalArgumentException {
        if (index == 0 ) {
            addfirst(data);
            return;
        }
        Node prev = findNode(index-1);
        if (prev == null) {
            throw  illegalIndex(index);
        }
        prev.next = new Node(data, prev.next);

    }


    //查找节点
    private Node findNode(int index) {

        int i = 0;
        for (Node p = head; p!= null; p = p.next,i++){
            if (i == index)
                return p;
        }
        return null;//如果没有找到，返回null
    }

    public int get(int index) {
        Node p = findNode(index);
        if (p == null){
            illegalIndex(index);
        }

        return p.data;
    }


    //索引不合法，抛出异常
    private  IllegalArgumentException illegalIndex(int index) {
        throw new IllegalArgumentException(
                String.format("Index: [%d]不合法%n", index));
    }



    //删除首节点
    public void removefirst(int index) {
        if (head == null)
            throw new IllegalArgumentException("空链表");
        head = head.next;
    }

    //根据索引删除节点
    public void remove(int index) {
        if (index == 0) {
            removefirst(index);
            return;
        }
        Node prev = findNode(index-1);//上一个节点
        if (prev == null) {
            throw  illegalIndex(index);
        }
        Node remove = prev.next;//被删除的节点
        if (remove == null) {
            throw  illegalIndex(index);
        }
        prev.next = remove.next;

    }

    // 根据索引修改节点的值
    public void set(int index, int data) throws IllegalArgumentException {
        Node node = findNode(index); // 查找指定索引的节点
        if (node == null) {
            throw illegalIndex(index); // 如果节点不存在，抛出索引不合法的异常
        }
        node.data = data; // 修改节点的值
    }

}

测试代码：

package school.singlelinkedlist;

import org.junit.Test;


public class SingleLinkedListTest {


    @Test
    public void test1() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addfirst(2);
        list.addfirst(3);
        list.addfirst(4);
        list.addfirst(5);
        list.traverse(data -> {
            System.out.println(data + " ");
        });

        list.traverse2(data -> {
            System.out.println(data + " ");
        });
    }

    @Test
    public void test2() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addfirst(2);
        list.addfirst(3);
        list.addfirst(4);
        list.addfirst(5);

        for (Integer i : list) {
            System.out.println(i);
        }
    }

    @Test
    public void test3() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addlast(2);
        list.addlast(3);
        list.addlast(4);

        for (Integer i : list) {
            System.out.println(i);
        }

    }

    @Test
    public void test4() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addlast(2);
        list.addlast(3);
        list.addlast(4);

        System.out.println(list.get(0));
        System.out.println(list.get(1));
    }

    @Test
    public void test5() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addlast(2);
        list.addlast(3);
        list.addlast(4);

        list.add(2, 5);
//        list.add(6, 6);


        for (Integer i : list) {
            System.out.println(i);
        }
    }

    @Test
    public void test6() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addlast(2);
        list.addlast(3);
        list.addlast(4);
        list.addlast(5);

        for (Integer i : list) {
            System.out.println(i);
        }
        System.out.println("------------删除后-------------");
//        list.removefirst(0);
        list.remove(2);
        for (Integer i : list) {
            System.out.println(i);
        }
    }


    @Test
    public void test7() {
        SingleLinkedList list = new SingleLinkedList();
        list.addfirst(1);
        list.addlast(2);
        list.addlast(3);
        list.addlast(4);
        list.addlast(5);

        list.set(1,1);
        for (Integer i : list) {
            System.out.println(i);
        }
    }





}

关键点解释

head = new Node(data, head);

这行代码的作用是在链表的头部添加一个新节点。具体解释如下：

  1. new Node(data, head):

    • new Node(data, head)是通过调用Node类的构造函数来创建一个新的节点对象。在构造函数中，data代表新节点的数据值，而head代表当前头节点，即链表的第一个节点。
    • 通过传入head作为构造函数的第二个参数，新节点的next指针将指向当前的头节点。因此，新节点成为链表中的第一个节点，而原来的头节点成为新节点的下一个节点。

  2. head = new Node(data, head);:

    • 这行代码将head引用更新为新的节点对象。通过这种方式，链表的头节点即被更新为新创建的节点。

        简而言之，这个操作在链表的头部插入了一个新的节点，使新的节点成为链表的第一个节点。旧的头节点则被移到第二个位置。

头节点设置为哨兵节点

package school.singlelinkedlist;

import java.util.Iterator;
import java.util.function.Consumer;

/**
 * 文件名: null.java
 * 作者: 20526
 * 创建时间: 2024/9/6 15:17
 * 描述:单向链表实现
 */
public class SingleLinkedList implements Iterable<Integer>{

//    private Node head = null; // 头节点
    private Node head = new Node(0, null);
    //节点类
    public static class Node {
        int data;
        Node next;

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

    }


    //链表遍历
    public void traverse(Consumer <Integer> consumer) {
        Node current = head.next;//定义一个指针，进行遍历，默认指向头节点

        while (current!= null) {
            consumer.accept(current.data);//调用consumer.accept(data)方法，对当前节点的数据进行处理
            current = current.next;//指针向后移动
        }
    }
    public void traverse2(Consumer <Integer> consumer){
        for (Node current = head.next; current!= null; current = current.next){
            consumer.accept(current.data);
        }
    }

    //实现迭代器，可以用增强for循环遍历
    @Override
    public Iterator<Integer> iterator() {
        //匿名内部类
        return new Iterator<Integer>() {
            Node current  = head.next;
            @Override
            public boolean hasNext() { //判断是否有下一个节点
                return current!= null;
            }

            @Override
            public Integer next() { //返回当前值，并指向下一个节点

                int value = current.data;
                current = current.next;
                return value;
            }
        };

    }

    //添加节点到链表头
    public void addfirst(int data) {
        add(0, data);
    }

    //查找链表尾节点
    private Node findlast(){
        Node p ;

        for (p = head; p.next!= null; p = p.next){

        }
        return p;
    }

    //添加节点到链表尾
    public void addlast(int data){
        Node last = findlast();
        last.next = new Node(data, null);

    }

    //根据索引插入节点
    public void add(int index, int data) throws IllegalArgumentException {
        Node prev = findNode(index-1);
        if (prev == null) {
            throw  illegalIndex(index);
        }
        prev.next = new Node(data, prev.next);

    }


    //查找节点
    private Node findNode(int index) {

        int i = -1;
        for (Node p = head; p!= null; p = p.next,i++){
            if (i == index)
                return p;
        }
        return null;//如果没有找到，返回null
    }

    public int get(int index) {
        Node p = findNode(index);
        if (p == null){
            illegalIndex(index);
        }

        return p.data;
    }


    //索引不合法，抛出异常
    private  IllegalArgumentException illegalIndex(int index) {
        throw new IllegalArgumentException(
                String.format("Index: [%d]不合法%n", index));
    }



    //删除首节点
    public void removefirst(int index) {
        remove(0);
    }

    //根据索引删除节点
    public void remove(int index) {

        Node prev = findNode(index-1);//上一个节点
        if (prev == null) {
            throw  illegalIndex(index);
        }
        Node remove = prev.next;//被删除的节点
        if (remove == null) {
            throw  illegalIndex(index);
        }
        prev.next = remove.next;

    }

    // 根据索引修改节点的值
    public void set(int index, int data) throws IllegalArgumentException {
        Node node = findNode(index); // 查找指定索引的节点
        if (node == null) {
            throw illegalIndex(index); // 如果节点不存在，抛出索引不合法的异常
        }
        node.data = data; // 修改节点的值
    }

}

        下面是将头节点设置为哨兵节点后的改动优化，与上面的略有不同，不过大致思路都一样，去掉了一些特殊情况的处理

  1. 哨兵节点：代码中private Node head = new Node(0, null);定义了一个哨兵节点。这个节点不存储实际数据，仅用于简化链表操作。

  2. 遍历方法：traverse和traverse2方法展示了两种遍历链表的方式，均使用Consumer接口来处理每个节点的数据。

  3. 迭代器实现：iterator方法实现了Iterable接口，使得链表可以通过增强for循环进行遍历。

  4. 插入和删除操作：add和remove方法展示了如何在链表中插入和删除节点。由于使用了哨兵节点，这些操作变得更加简单和统一。

  5. 异常处理：illegalIndex方法用于处理索引不合法的情况，抛出IllegalArgumentException异常。

        通过使用哨兵节点，链表的操作变得更加简洁和高效，避免了在处理头节点时需要特殊处理的麻烦。 希望对你有所帮助……

Bro_cat
关注
专栏目录
华为OD机试Java - 单向链表中间结点
steven_my的博客
05-21 32
给定一个单链表L，请编写程序输出L中间结点保存的数据，如果有两个中间结点，则输出第二个中间结点保存的数据。 例如：给定L为 1-> 7 -> 5，则输出应该为7；给定L为 1-> 2 -> 3 -> 4，则输出应该为3。
Java实现单向链表反转
08-27
Java实现单向链表反转 Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。 单向链表...
java 单向链表实现
weixin_30333885的博客
03-04 65
1 class Node{//Node类 2 private String data; 3 private Node next; 4 public Node(String data){ 5 this.data=data; 6 } 7 publ...
Java实现单向链表
weixin_50394543的博客
03-16 3584
Java实现单向链表
Java实现单向链表的基本功能详解
08-27
主要给大家介绍了关于Java实现单向链表基本功能的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
java单向链表的实现实例
09-04
在这个实例中，我们将详细讨论如何在Java中实现单向链表，包括创建节点、插入节点、显示链表、删除节点、清空链表以及获取链表中指定范围内的数据。 首先，我们定义一个名为`Node`的类来表示链表中的节点。这个类有...
java实现单向链表
西凉的悲伤博客
05-06 1201
目录单向链表示意图：单向链表实现代码：测试：结果： 单向链表示意图： 以下是单链表相对于双链表的优缺点。 优点 （1) 只有一个指向下一个节点的指针。 （2) 单向链表增加删除节点简单。遍历时候不会死循环。 缺点 （1) 只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 单向链表实现代码： import java.util.Arrays; import java.util.Iterator; import java.util.NoSuchElementException; import j
数据结构_链表
kk阿彬
11-21 179
文章目录 C语言没有实现链表，因此Redis自己实现了一套 链表在 Redis 中的应用非常广泛， 比如列表键的底层实现之一就是链表。 当一个列表键包含了数量比较多的元素， 又或者列表中包含的元素都是比较长的字符串时， Redis 就会使用链表作为列表键list的底层实现。发布与订阅、慢查询、监视器等也用到了链表。 list结构为链表提供了表头指针head、 表尾指针tail ， 以及链表长度计数器len,而dup 、 free和match成员则是用于实现多态链表所需的类型特定函数： 口dup函数用于复
Java单向链表的实现
旭日东升的博客
02-28 1370
本篇博客将介绍以下内容： -什么是java链表，它有什么特点？ -java链表基本功能的实现方法 -什么是泛型？泛型有什么用？
【Java】实现个单向链表
渐若窥宏大的博客
05-25 147
实现个单向链表 public class SingleLinkedList { //这里不需要数组，不需要其他的复杂的结构，我只要记录单向链表的“头”结点 private Node first;//first中记录的是第一个结点的地址 private int total;//这里我记录total是为了后面处理的方便，例如：当用户获取链表有效元素的个数时，不用现数，而是直接返回total等 /* * 内部类，因为这种Node结点的类型，在别的地方没有用，只在单向链表中，用于存储和表示它的结点关
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值