单向链表-线性表-数据结构和算法

最新推荐文章于 2024-09-24 21:14:08 发布
最新推荐文章于 2024-09-24 21:14:08 发布
阅读量340 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 单向链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaogzhen/article/details/127271828
版权

1 概述

  • 链表定义：

    • 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

  • 链表特点：添加删除快，查找慢

  • 链表有很多种不同的类型：单向链表，双向链表以及循环链表。

  • 单链表：

    • 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；

    • 图示：在这里插入图片描述

2 API

类名LinkList
构造方法LinkList()
成员方法1. public boolean add(E e)：添加元素
2. public void add(int index,E e)：指定位置添加元素
3. public void clear()：清空链表
4. public E get(int index)：获取指定索引位置的元素
5. public int indexOf(Object o)：返回元素在链表中的位置索引
6. public E remove(int index)：删除指定索引位置的元素
7. public boolean remove(Object o)：删除链表中的元素
8. public E set(int index,E e)：给指定索引位置节点设置值
9. public int size()：获取链表的大小
成员变量1. private int size：链表大小
2. private Node<E> first：链表头指针
3. private Node<E> last：链表尾指针
成员内部类1. private class Itr：迭代器
2. private static class Node<E>：节点类
类名Itr
构造方法Itr(int index)
成员变量1. private Node<E> lastReturned：上一个返回的节点
2. private Node<E> next：下一个节点
3. private nextIndex：下一个索引
成员方法1. public boolean hasNext()：是否有下一个节点
2.public E next()：下一个节点
3. public void remove()：移除当前节点
4. public void forEachRemaing(Consumer<? super E> action)

3 初级实现

3.1 源代码及分析

代码如下：

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

/**
 * @author Administrator
 * @version 1.0
 * @description 单向链表
 * @date 2022-10-08 21:32
 */
public class LinkList<E> {
    /**
     * 节点类
     * @param <E>
     */
    private static class Node<E> {
        E item;
        Node<E> next;
        Node(E item, Node<E> next) {
            this.item = item;
            this.next = next;
        }
    }

    private int size;
    private Node<E> first;
    private Node<E> last;

    public LinkList() {}

    /**
     * 添加元素e
     * @param e     目标元素
     * @return      添加是否成功
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    /**
     * 插入链表末尾
     * @param e     目标元素
     */
    private void linkLast(E e) {
        Node<E> l = last;
        Node<E> newNode = new Node<>(e, null);
        last = newNode;
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
    }

    /**
     * 插入链表末尾
     * @param e     目标元素
     */
    private void linkFirst(E e) {
        Node<E> f = first;
        Node<E> newNode = new Node<>(e, null);
        first = newNode;
        if (f == null) {
            last = newNode;
        } else {
            newNode.next = f;
        }
        size++;
    }

    /**
     * 指定索引位置插入元素
     * @param index     索引
     * @param e         目标元素
     */
    public void add(int index,E e) {
        checkPositionIndex(index);
        if (index == size) {
            linkLast(e);
        } else if (index == 0) {
            linkFirst(e);
        } else {
            linkAfter(e, nodeBefore(index));
        }
    }

    private Node<E> nodeBefore(int index) {
        Node<E> x = first;
        for (int i = 0; i < index - 1; i++) {
            x = x.next;
        }
        return x;
    }

    private void linkAfter(E e, Node<E> before) {
//        assert before != null;
        before.next = new Node<>(e, before.next);
    }

    private Node<E> node(int index) {
        Node<E> x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        return x;
    }

    /**
     * 检查位置索引是否合法
     * @param index     目标索引
     */
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }


    /**
     * 检查是否合法的索引
     * @param index     目标索引
     * @return          是否合法
     */
    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    /**
     * 情况链表
     */
    public void clear() {
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x = next;
        }
        first = last = null;
        size = 0;
    }

    /**
     * 获取指定索引处的元素
     * @param index     目标索引
     * @return          指定索引处的元素
     */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    /**
     * 返回元素在链表中的索引位置
     * @param o     目标元素
     * @return      目标元素在链表中的索引
     */
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    return index;
                }
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    return index;
                }
                index++;
            }
        }
        return -1;
    }

    /**
     * 移除链表指定索引位置的元素
     * @param index     目标索引
     * @return          目标索引位置的元素值
     */
    public E remove(int index) {
        checkElementIndex(index);
        if (index == 0 || size == 1) {
            return unlinkFirst();
        }
        return unlink(nodeBefore(index));
    }

    private E unlinkFirst() {
        // assert first != null;
        Node<E> f = this.first;
        E item = f.item;
        Node<E> next = this.first.next;
        f.item = null;
        f.next = null;
        first = next;
        if (next == null) {
            last = null;
        }
        size--;
        return item;
    }

    private E unlink(Node<E> prev) {
        // assert prev != null && prev.next != null;
        Node<E> t = prev.next;
        Node<E> next = t.next;
        E item = t.item;
        t.item = null;
        t.next = null;
        prev.next = next;
        if (next == null) {
            last = prev;
        }
        size--;
        return item;
    }

    /**
     * 移除链表中的指定元素
     * @param o     目标元素
     * @return      是否移除成功
     */
    public boolean remove(Object o) {
        Node<E> prev = null;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next, prev = x) {
                if (x.item == null) {
                    if (prev == null) {
                        unlinkFirst();
                    } else {
                        unlink(prev);
                    }
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next, prev = x) {
                if (o.equals(x.item)) {
                    if (prev == null) {
                        unlinkFirst();
                    } else {
                        unlink(prev);
                    }
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 设置指定索引位置元素的值
     * @param index     目标位置索引
     * @param e         要替换的值
     * @return          被替换的旧值
     */
    public E set(int index, E e) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = e;
        return oldVal;
    }

    /**
     * 返回链表的大小
     * @return  链表的大小
     */
    public int size() { return size; }

    public Iterator<E> iterator() {
        return new Itr(0);
    }

    public Iterator<E> listIterator(int index) {
        checkElementIndex(index);
        return new Itr(0);
    }

    @Override
    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext()) {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext()) {
                return sb.append(']').toString();
            }
            sb.append(',').append(' ');
        }
    }

    private class Itr implements Iterator<E> {

        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;

        public Itr(int index) {
            next = node(index);
            nextIndex = index;
        }

        @Override
        public boolean hasNext() {
            return nextIndex < size;
        }

        @Override
        public E next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        @Override
        public void remove() {
            if (lastReturned == null) {
                throw new IllegalStateException();
            }
            Node<E> prev = node(nextIndex - 1);
            if (prev == null) {
                unlinkFirst();
            } else {
                unlink(prev);
            }
            lastReturned = null;
            nextIndex--;
        }

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while ( nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
        }
    }
}
  • 说明：
    • 此实现为单链表，参考LinkedList源码，LinkedList源码为双向链表，我们放到后面讨论。
    • 我们这里没有做迭代遍历时的同步访问控制，即我们在LinkedList源码看到的modCount检测。
  • 代码分析对比：
    • LinkedList源码在unlink移除节点的时候，参数就是目标节点（当前节点），因为它是双向链表，容易获取前驱节点和后继节点；而我们这里是单向链表，所有我们这里移除节点是时候unlinkBefore就传递的是目标节点的前驱节点。
    • LinkedList源码换实现了Deque接口 双向队列和栈相关的代码，我们后面遇到的时候在讲解。

3.2 简单测试

测试代码：

LinkList<Integer> slj = new LinkList<>();
        slj.add(22);
        slj.add(5242);
        slj.add(52);
        System.out.println(slj);
        System.out.println("原数组大小: " + slj.size() );
        System.out.println("====移除索引为0的元素: " + slj.remove(0));
//        System.out.println("====移除索引为1的元素: " + slj.remove(1));
        System.out.println(slj);
        System.out.println("移除后数组大小: " + slj.size());

        Iterator<Integer> iterator = slj.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
测试结果：
[22, 5242, 52]
原数组大小: 3
====移除索引为0的元素: 22
[5242, 52]
移除后数组大小: 2
5242
52

后记

​ 如果小伙伴什么问题或者指教，欢迎交流。

❓QQ:806797785

⭐️源代码仓库地址：https://gitee.com/gaogzhen/algorithm

参考：

[1]百度百科.链表[EB/OL].2022-09-17/2022-10-08.

[2]百度百科.单向链表[EB/OL].2022-06-27/2022-10-08.

[3]黑马程序员.黑马程序员Java数据结构与java算法全套教程，数据结构+算法教程全资料发布，包含154张java数据结构图[CP/OL].2020-01-18/2022-10-08.

gaog2zh
关注
专栏目录
数据结构学习--线性表及其应用--链表
06-25
单向链表是最简单的链表形式，每个节点包含一个数据域和一个指向下一个节点的指针。在本程序中，数据域被定义为字符串类型，这样可以存储各种文本信息。链表的头节点是一个特殊的节点，其指针域指向链表的第一个实际...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每...通过C语言实现，我们可以直观地理解链表的工作原理，这对于进一步学习高级数据结构和算法具有重要意义。
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法---单向链表
weixin_73602725的博客
03-01 1782
单向链表的详细讲解（附完整版）
c++数据结构算法复习基础-- 4 -- 线性表-单向循环链表-常用操作接口-复杂度分析
kyrie_sakura的博客
08-17 322
c++数据结构算法复习基础--线性表-单向循环链表-常用操作接口-复杂度分析
数据结构与算法--线性表
joker_sxj的博客
12-08 5585
数据结构与算法--线性表
数据结构与算法分析-线性表
weixin_45976751的博客
11-06 829
线性表 考试内容 线性表的定义 线性表是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 顺序表的定义及其特点 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素， 这种表示也称作线性表的顺序存储结构或顺序映像。通常,称这种存储结构的线性表为顺序表。 特点：逻辑上相邻的数据元素， 其物理次序也是相邻的。 链式表的定义及其特点 线性表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的） 线性表的应用
【数据结构篇C++实现】- 线性表 - 顺序表和链表
陈七的博客，学习知识分享，期待与大家的交流
03-20 3562
线性表知识总结，一文搞懂什么是顺序表与链表，以及常见的操作
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 5086
本文详细介绍带头双向循环链表，内容较为丰富
数据结构与算法---线性表1
qq_65198010的博客
03-15 701
线性表 重点： 线性表的逻辑结构 线性表的顺序存储结构 线性表的链式存储结构 一元多项式的表示及相加 定义： 线性表n(n>=0)的同质元素的有限数列，每个元素有唯一的前驱和后继。首元素只有后继，尾元素只有前驱，n为0时是空表，n叫做线性表的长度。 线性表的基本操作 初始化 InitList(&L) 销毁 DestroyList(&L) 清空 ClearList(&L) 判断空表 ListEmpty(L) 求长度 ListLength(L) 取i值 GetElem(L,i
数据结构与算法总结——线性表
sinat_39377093的博客
07-22 1681
数据结构与算法之线性表
数据结构与算法-单向链表
AABFF的博客
05-09 271
3、获取节点：获取链表中指定位置的节点，该节点的数据域设置为指定位置的节点的数据，指针域指向该节点的下一个节点。2、删除节点：从链表的头部删除一个节点，该节点的数据域设置为删除节点的数据，指针域指向删除节点的前一个节点。1、插入节点：在链表的头部插入一个新节点，该节点的数据域设置为新节点的数据，指针域指向新节点的下一个节点。2、指针域：存储指向下一个节点的指针，通常包括当前节点的地址和指向下一个节点的指针。1、数据域：存储节点的数据，通常包括节点的值和指向下一个节点的指针。
数据结构实验报告-线性表-线性表基本操作算法5分-实验内容及要求.docx
03-11
本实验通过构建两种不同的线性表存储结构——顺序表与单向链表，实现了对线性表的基本操作，如插入、删除和查找等功能，并通过具体的测试实例验证了程序的正确性。此实验不仅加深了学生对线性表的理解，还提高了其...
数据结构实验报告-线性表-基于链表的多项式乘法-实验内容及要求.docx
05-03
1. **链表数据结构**：实验中使用了单向链表来存储多项式的系数和指数。链表是一种非连续的存储结构，每个节点包含数据元素和指向下一个节点的指针。在这个实验中，链表的节点包含了系数（co）和指数（ex），并且...
算法-理论基础- 线性表- 双向链表（包含源程序）.rar
09-16
线性表是计算机科学中数据结构的基础概念之一，它是由相同类型元素构成的有序序列。...理解和掌握双向链表的原理和操作，对于学习数据结构和算法至关重要。通过实践源程序，可以进一步巩固理论知识，提升编程能力。
考研数据结构——C语言实现插入排序
最新发布
weixin_58879477的博客
09-24 406
C语言实现插入排序
数据结构：树、森林
pranaa的博客
09-24 852
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
javaScript 数据结构可变性和不可变性
everyStudy的博客
09-24 404
【代码】javaScript 数据结构可变性和不可变性。
Java-数据结构-排序(三) |ू･ω･` )
2303_80388948的博客
09-24 738
OK，到这里呢我们的排序呢就结束了，这次关于排序的代码呢还是比较多的，要认真的理解它们，同时要画图的去理解它们的执行流程。下一篇博客呢我们就要介绍关于Map与Set的知识啦，让我们尽情期待吧！！！拜拜~~~
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

gaog2zh

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

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

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

打赏作者

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

抵扣说明：

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

余额充值