脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java 单向链表

Java 数据结构与算法系列精讲之单向链表

 更新时间：2022年02月18日 10:59:12   作者：我是小白呀  
单向链表特点是链表的链接方向是单向的，访问要通过顺序读取从头部开始。链表是使用指针构造的列表，是由一个个结点组装起来的，又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，head指针指向第一个结点称为表头，而终止于最后一个指向nuLL的指针

概述

从今天开始, 小白我将带大家开启 Jave 数据结构 & 算法的新篇章.

链表

链表 (Linked List) 是一种递归的动态数据结构. 链表以线性表的形式, 在每一个节点存放下一个节点的指针. 链表解决了数组需要先知道数据大小的缺点, 增加了节点的指针域, 空间开销较大.

链表包括三类:

  • 单向链表
  • 双向链表
  • 循环链表

单向链表

单向链表 (Single Linked List) 是链表中最简单的一种形式. 单向链表每个节点包含两个部分, 第一部分是信息, 第二部分是下一个节点. (元素 + 指针)

单向链表实现

Node 类

// Node类
private class Node {


    public E e;  // 元素
    private SingleLinkedList.Node next;  // 下一个节点

    // 构造
    public Node(E e) {
        this.e = e;
        this.next = null;
    }

    @Override
    public String toString() {
        return e.toString();
    }
}

add 方法

// 添加数据
public void add(int index, E e) {

    // 检查索引是否越界
    if (index < 0 || index > size) {
        throw new RuntimeException("Invalid Index");
    }

    // 获取index前一个节点
    SingleLinkedList.Node prev = dummyHead;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }

    // 添加数据
    SingleLinkedList.Node node = new SingleLinkedList.Node(e);
    node.next = prev.next;
    prev.next = node;
    size++;
}

remove 方法

// 删除数据
public void remove(int index) {

    // 检查索引是否越界
    if (index < 0 || index > size) {
        throw new RuntimeException("Invalid Index");
    }

    // 获取index前一个节点
    Node prev = dummyHead;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }

    // 删除数据
    Node retNode = prev.next;
    prev.next = retNode.next;

    size --;
}

get 方法

// 通过索引获取链表数数据
public E get(int index) {

    // 检查索引是否越界
    if (index < 0 || index > size) {
        throw new RuntimeException("Invalid Index");
    }

    // 获取index前一个节点
    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }
    
    return cur.e;
}

set 方法

// 通过索引设置链表数据
public E set(int index,E e) {

    // 检查索引是否越界
    if (index < 0 || index > size) {
        throw new RuntimeException("Invalid Index");
    }

    // 获取index前一个节点
    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }

    // 设置新值
    cur.e = e;

   return cur.e;
}

contain 方法

// 链表是否包含元素
public boolean contains(E e) {
        Node cur = dummyHead.next;

        // 遍历所有节点
        while (cur != null) {
            if (cur.e.equals(e)) {
                return true;
            }
            cur = cur.next;
        }
    return false;
}

main

// main
public static void main(String[] args) {

    // 创建单向链表
    SingleLinkedList<Integer> singleLinkedList = new SingleLinkedList<>();

    // 添加数据
    for (int i = 0; i < 8; i++) {
        singleLinkedList.addFirst(i);
        System.out.println(singleLinkedList);
    }

    // 是否包含元素
    System.out.println(singleLinkedList.contains(0));
    System.out.println(singleLinkedList.contains(10));

    // set
    singleLinkedList.set(0, 9);
    singleLinkedList.set(1, 7);
    System.out.println(singleLinkedList);

    // 删除数据
    for (int i = 0; i < 8; i++) {
        singleLinkedList.remove(0);
        System.out.println(singleLinkedList);
    }
}

输出结果:

0->NULL
1->0->NULL
2->1->0->NULL
3->2->1->0->NULL
4->3->2->1->0->NULL
5->4->3->2->1->0->NULL
6->5->4->3->2->1->0->NULL
7->6->5->4->3->2->1->0->NULL
true
false
9->7->5->4->3->2->1->0->NULL
7->5->4->3->2->1->0->NULL
5->4->3->2->1->0->NULL
4->3->2->1->0->NULL
3->2->1->0->NULL
2->1->0->NULL
1->0->NULL
0->NULL
NULL

完整代码

public class SingleLinkedList<E> {


    private Node dummyHead;  // 头指针
    private int size;  // 链表大小

    // Node类
    private class Node {


        public E e;  // 元素
        private Node next;  // 下一个节点

        // 构造
        public Node(E e) {
            this.e = e;
            this.next = null;
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    // 构造
    public SingleLinkedList() {
        dummyHead = new Node(null);
        size = 0;
    }

    // 表首添加元素
    public void addFirst(E e) {
        add(0, e);
    }

    // 表尾添加元素
    public void addLast(E e){
        add(size, e);
    }

    // 添加数据
    public void add(int index, E e) {

        // 检查索引是否越界
        if (index < 0 || index > size) {
            throw new RuntimeException("Invalid Index");
        }

        // 获取index前一个节点
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }

        // 添加数据
        Node node = new Node(e);
        node.next = prev.next;
        prev.next = node;
        size ++;
    }

    // 删除数据
    public void remove(int index) {

        // 检查索引是否越界
        if (index < 0 || index > size) {
            throw new RuntimeException("Invalid Index");
        }

        // 获取index前一个节点
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }

        // 删除数据
        Node retNode = prev.next;
        prev.next = retNode.next;

        size --;
    }


    // 通过索引获取链表数数据
    public E get(int index) {

        // 检查索引是否越界
        if (index < 0 || index > size) {
            throw new RuntimeException("Invalid Index");
        }

        // 获取index前一个节点
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }

        return cur.e;
    }

    // 通过索引设置链表数据
    public E set(int index,E e) {

        // 检查索引是否越界
        if (index < 0 || index > size) {
            throw new RuntimeException("Invalid Index");
        }

        // 获取index前一个节点
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }

        // 设置新值
        cur.e = e;

        return cur.e;
    }

    // 链表是否包含元素
    public boolean contains(E e) {
        Node cur = dummyHead.next;

        // 遍历所有节点
        while (cur != null) {
            if (cur.e.equals(e)) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    // 获取链表大小
    public int getSize() {
        return size;
    }

    // 判断链表是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public String toString() {

        StringBuilder builder = new StringBuilder();
        Node cur = dummyHead.next;
        while (cur != null) {
            builder.append(cur + "->");
            cur = cur.next;
        }
        builder.append("NULL");
        return builder.toString();
    }

    // main
    public static void main(String[] args) {

        // 创建单向链表
        SingleLinkedList<Integer> singleLinkedList = new SingleLinkedList<>();

        // 添加数据
        for (int i = 0; i < 8; i++) {
            singleLinkedList.addFirst(i);
            System.out.println(singleLinkedList);
        }

        // 是否包含元素
        System.out.println(singleLinkedList.contains(0));
        System.out.println(singleLinkedList.contains(10));

        // set
        singleLinkedList.set(0, 9);
        singleLinkedList.set(1, 7);
        System.out.println(singleLinkedList);

        // 删除数据
        for (int i = 0; i < 8; i++) {
            singleLinkedList.remove(0);
            System.out.println(singleLinkedList);
        }
    }
}

到此这篇关于Java 数据结构与算法系列精讲之单向链表的文章就介绍到这了,更多相关Java 单向链表内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Java AES加密和解密教程

    Java AES加密和解密教程

    这篇文章主要介绍了Java AES加密和解密的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
    2020-12-12
  • Java实现中国象棋的示例代码

    Java实现中国象棋的示例代码

    中国象棋是起源于中国的一种棋，属于二人对抗性游戏的一种，在中国有着悠久的历史。由于用具简单，趣味性强，成为流行极为广泛的棋艺活动。本文将利用Java实现这一经典游戏，需要的可以参考一下
    2022-02-02
  • Java中的日期时间处理及格式化处理

    Java中的日期时间处理及格式化处理

    这篇文章主要介绍了Java中的日期时间处理及格式化处理方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-08-08
  • JSON Web Token(JWT)原理入门教程详解

    JSON Web Token(JWT)原理入门教程详解

    这篇文章主要为大家介绍了JSON Web Token(JWT)原理入门教程详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪
    2022-04-04
  • tio-boot jfinal-plugins框架整合redis示例详解

    tio-boot jfinal-plugins框架整合redis示例详解

    这篇文章主要为大家介绍了tio-boot jfinal-plugins框架整合redis示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-12-12
  • 详解ElasticSearch6.4.0集群搭建

    详解ElasticSearch6.4.0集群搭建

    这篇文章主要介绍了详解ElasticSearch6.4.0集群搭建，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-09-09
  • spring boot使用自定义配置的线程池执行Async异步任务

    spring boot使用自定义配置的线程池执行Async异步任务

    这篇文章主要介绍了spring boot使用自定义配置的线程池执行Async异步任务，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-01-01
  • springmvc接口接收参数与请求参数格式的整理

    springmvc接口接收参数与请求参数格式的整理

    这篇文章主要介绍了springmvc接口接收参数与请求参数格式的整理，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-11-11
  • springboot中设置定时任务的三种方法小结

    springboot中设置定时任务的三种方法小结

    在我们开发项目过程中,经常需要定时任务来帮助我们来做一些内容,本文介绍了springboot中设置定时任务的三种方法,主要包括@Scheduled注解,Quartz框架和xxl-job框架的实现,感兴趣的可以了解一下
    2023-12-12
  • Java实战网上电子书城的实现流程

    Java实战网上电子书城的实现流程

    读万卷书不如行万里路，只学书上的理论是远远不够的，只有在实战中才能获得能力的提升，本篇文章手把手带你用java+SSM+JSP+maven+Mysql实现一个网上电子书城,大家可以在过程中查缺补漏，提升水平
    2022-01-01

最新评论