手写链表底层实现(java实现)

最新推荐文章于 2024-05-05 22:29:45 发布
最新推荐文章于 2024-05-05 22:29:45 发布
阅读量4.1k 收藏 28
点赞数 4
分类专栏： 数据结构与算法 文章标签： 链表 栈 队列 底层原理 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_ym_ww/article/details/89372222
版权

文章目录

打造属于自己的链表

​ 前面数组篇中的动态数组实现，以及基于数组实现的栈和队列，它们的底层依旧是依托于静态数组，靠的是resize来解决固定容量的问题。但是链表就不同了，他实现了真正的动态数据结构，通过指针的指向来实现元素之间的关系依赖。
1553219910234

数组和链表的对比

  1. 数组支持快速查询，是因为在创建数组的时候，在堆中创建了连续的空间。正因此，数组在插入和删除元素的时候可能需要开辟额外的空间，所以慢了。
  2. 而链表真正的优点是实现了动态数据结构，你不要考虑容量的问题，有新元素插入只需要改变一下指针的指向就可以。但也因此丧失了快速查找的功能，因为在堆中元素与元素之间不是连续的空间，它们可以分布各地，唯一的联系那就是指针了。

链表

经过上面的一通操作(哈塞给)之后，相信对数组和链表有了更深刻的认识，下面我们来实现属于自己的链表。

package design.linkedlist;

/**
 * @program: design
 * @description: 链表实现类, 增删改查时间复杂度：O(n)
 * @author: cyj
 * @create: 2019-03-21 11:32
 **/
public class LinkedList<E> {
    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

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

    //虚拟头节点
    private Node dummyHead;
    int size;

    public LinkedList() {
        dummyHead = new Node(null, null);
        size = 0;
    }

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

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

    /**
     * 在链表的index添加元素e
     * 在链表中不是一个常用的操作，主要理解
     * 时间复杂度：O(n)
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.  Illegal 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;

        prev.next = new Node(e, prev.next);
        size++;

    }

    /**
     * 在链表末尾添加新得元素e
     * 时间复杂度：O(n)
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    /**
     * 在链表头添加元素
     * 时间复杂度：O(1)
     */
    public void addFirst(E e) {
//        Node node = new Node(e);
//        node.next = head;
//        head = node;

//        head = new Node(e, head);
//        size++;

        add(0, e);
    }

    /**
     * 获得链表的index处的元素e
     * 在链表中不是一个常用的操作，主要联系理解
     * 时间复杂度：O(n)
     */
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }

    /**
     * 获得链表的第一个元素
     *
     * @return
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 获得链表的最后一个元素
     *
     * @return
     */
    public E getLast() {
        return get(size - 1);
    }

    /**
     * 修改链表的第index个位置的元素为e
     * 时间复杂度：O(n)
     *
     * @param index
     * @param e
     */
    public void set(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Update failed. Illegal index.");
        }
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }

    /**
     * 删除链表的第index个位置的元素为e
     * 时间复杂度：O(n)
     *
     * @param index
     */
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Update failed. Illegal index.");
        }
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        size--;
        return retNode.e;
    }

    /**
     * 删除链表第一个元素
     * 时间复杂度：O(1)
     *
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 删除链表最后一个元素
     * 时间复杂度：O(n)
     *
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }

    /**
     * 查找链表中是否有元素e
     * 时间复杂度：O(n)
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        Node cur = dummyHead.next;
        while (cur != null) {
            if (cur.e.equals(e)) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node cur = dummyHead.next;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
//        for (Node cur=dummyHead.next;cur!=null;cur=cur.next) {
//            res.append(cur + "->");
//        }
        res.append("NULL");
        return res.toString();
    }

    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < 5; i++) {
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }
		
        //在索引为2的地方添加元素666
        linkedList.add(2, 666);
        System.out.println(linkedList);
		
        //删除索引为2的元素
        linkedList.remove(2);
        System.out.println(linkedList);

        //删除链表第一个元素
        linkedList.removeFirst();
        System.out.println(linkedList);

        //删除链表最后一个元素
        linkedList.removeLast();
        System.out.println(linkedList);
    }
}


运行结果：
0->NULL
1->0->NULL
2->1->0->NULL
3->2->1->0->NULL
4->3->2->1->0->NULL
4->3->666->2->1->0->NULL
4->3->2->1->0->NULL
3->2->1->0->NULL
3->2->1->NULL

链表的添加操作

在这里插入图片描述

在这里插入图片描述

​ 添加操作时，操作顺序很重要。找到要添加节点的前一个节点，然后将添加元素的指针指向节点的下一个节点，最后在把前一个节点的指针指向要添加的元素。

​ 可是头元素的没有前一个节点，因为需要设立一个虚拟头节点，即上面代码中的dummyHead。

在这里插入图片描述

链表的删除操作

链表的删除操作

基于链表实现栈和队列

链表栈

package design.linkedlist;

import design.stack.Stack;

/**
 * @program: design
 * @description: 链表栈的实现
 * @author: cyj
 * @create: 2019-03-21 15:47
 **/
public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> list;

    public LinkedListStack() {
        list = new LinkedList<>();
    }

    @Override
    public int getSize() {
        return list.getSize();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void push(E e) {
        list.addFirst(e);
    }

    @Override
    public E pop() {
        return list.removeFirst();
    }

    @Override
    public E peek() {
        return list.getFirst();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack : top ");
        res.append(list);
        return res.toString();
    }

    public static void main(String[] args) {
        LinkedListStack<Integer> stack = new LinkedListStack<>();

        for (int i = 0; i < 5; i++) {
            stack.push(i);
            System.out.println(stack);
        }

        stack.pop();
        System.out.println(stack);
    }
}


运行结果：
Stack : top 0->NULL
Stack : top 1->0->NULL
Stack : top 2->1->0->NULL
Stack : top 3->2->1->0->NULL
Stack : top 4->3->2->1->0->NULL
Stack : top 3->2->1->0->NULL

链表栈和数组栈的效率对比

package design.linkedlist;

import design.stack.ArrayStack;
import design.stack.Stack;

import java.util.Random;

/**
 * @program: design
 * @description: 数组栈与链表栈的效率对比
 * @author: cyj
 * @create: 2019-03-21 15:52
 **/
public class StackTest {
    /**
     * 测试使用stack运行opCount个push和pop操作所需要的时间，单位：秒
     *
     * @param stack
     * @param opCount
     * @return
     */
    private static double testStack(Stack<Integer> stack, int opCount) {
        long startTime = System.nanoTime();
        Random random = new Random();
        for (int i = 0; i < opCount; i++) {
            stack.push(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i = 0; i < opCount; i++) {
            stack.pop();
        }
        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;

        ArrayStack<Integer> arrayStack = new ArrayStack<>();
        double time1 = testStack(arrayStack, opCount);
        System.out.println("ArrayStack , time: " + time1 + " s");

        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        double time2 = testStack(linkedListStack, opCount);
        System.out.println("LinkedListStack , time: " + time2 + " s");

    }
}


(分别进行入队操作后再出队)
运行时间：
ArrayStack , time: 0.013294353 s
LinkedListStack , time: 0.010873164 s

可以看到 执行效率是差不多的。

链表队列

package design.linkedlist;

import design.queue.Queue;

/**
 * @program: design
 * @description: 实现链表队列
 * @author: cyj
 * @create: 2019-03-21 17:26
 **/
public class LinkedListQueue<E> implements Queue<E> {
    private class Node {
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

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

    private Node head, tail;
    private int size;

    public LinkedListQueue() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void enqueue(E e) {
        //tail为空，则head为空，链表为空
        if (tail == null) {
            tail = new Node(e);
            head = tail;
        } else {
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        Node retNode = head;
        head = head.next;
        retNode.next = null;
        if (head == null) {
            tail = null;
        }
        size--;
        return retNode.e;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        return head.e;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("LinkedListQueue : front ");
        Node cur = head;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }

        res.append("NULL  tail");
        return res.toString();
    }

    public static void main(String[] args) {
        LinkedListQueue<Integer> queue = new LinkedListQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);

            if (i % 3 == 2) {
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

运行时间：(front为队首，tail为队尾，每次增长3个元素，就去除队首元素)
LinkedListQueue : front 0->NULL  tail
LinkedListQueue : front 0->1->NULL  tail
LinkedListQueue : front 0->1->2->NULL  tail
LinkedListQueue : front 1->2->NULL  tail
LinkedListQueue : front 1->2->3->NULL  tail
LinkedListQueue : front 1->2->3->4->NULL  tail
LinkedListQueue : front 1->2->3->4->5->NULL  tail
LinkedListQueue : front 2->3->4->5->NULL  tail
LinkedListQueue : front 2->3->4->5->6->NULL  tail
LinkedListQueue : front 2->3->4->5->6->7->NULL  tail
LinkedListQueue : front 2->3->4->5->6->7->8->NULL  tail
LinkedListQueue : front 3->4->5->6->7->8->NULL  tail
LinkedListQueue : front 3->4->5->6->7->8->9->NULL  tail

数组队列，循环队列，链表队列的比较

package design.queue;

import design.linkedlist.LinkedListQueue;

import java.util.Random;

/**
 * @program: design
 * @description: 数组队列和循环队列的比较
 * @author: cyj
 * @create: 2019-03-20 16:20
 **/
public class QueueTest {
    /**
     * 测试使用q运行opCount个enqueue和dequeue操作所需要的时间，单位：秒
     *
     * @param q
     * @param opCount
     * @return
     */
    private static double testQueue(Queue<Integer> q, int opCount) {
        long startTime = System.nanoTime();
        Random random = new Random();
        for (int i = 0; i < opCount; i++) {
            q.enqueue(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i = 0; i < opCount; i++) {
            q.dequeue();
        }
        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;

        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        double time1 = testQueue(arrayQueue, opCount);
        System.out.println("ArrayQueue , time: " + time1 + " s");

        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2 = testQueue(loopQueue, opCount);
        System.out.println("LoopQueue , time: " + time2 + " s");

        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
        double time3 = testQueue(loopQueue, opCount);
        System.out.println("LinkedListQueue , time: " + time3 + " s");
    }
}



运行结果：
ArrayQueue , time: 3.300562516 s
LoopQueue , time: 0.012768131 s
LinkedListQueue , time: 0.006027373 s

可以看出来，还是链表队列省时间，因为没有涉及到查找的操作。但是当达到百万或者千万级别可能就会有出入了。
央小木
关注
  • 4
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java数据结构篇之链表
MasterJundarj的博客
09-23 2696
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
Java中的链表
weixin_52758364的博客
12-09 3339
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
2024年Java最新Java算法基础 - 单链表详解（文末有配套视频）(2)，2024Java面试题知识点总结
2401_83977696的博客
05-05 993
由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档还有更多面试复习笔记分享如下本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取CustNode类里面维护一个顾客的属性，为了方便起见，就直接用public了，反正我们自己用用的，无所谓。步骤 3 排队打饭。
Java数据结构 —— 手写线性结构（稀疏数组、栈、队列、链表）
小S的博客
02-24 814
当一个数组中大部分值为0,或者相同时，可以采用稀疏数组的方式来保存，从而节约存储空间，提高存储效率。Java描述的双向链表。Java描述的顺序表。
Java-双向链表的实现
xhmico的博客
04-03 1032
双向链表也称为双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个节点开始，都可以很方便地访问它的前驱节点和后继节点。可以使用一个head和tail分别指向头部和尾部的节点每个节点由三部分组成：前一个节点的指针prev保存的元素data后一个节点的指针next双向链表的第一个节点的 pre 是 null双向链表的最后一个节点的 next 是 null双向链表在进行增加和删除元素的时候，只需要改变prev和next的指向即可完成相关的操作。
Java实现链表
cainiaowangdake的博客
06-06 1260
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
java单向链表代码实现
12-25
下面我们将深入探讨Java中单向链表的实现、操作以及其在软件开发中的应用。 首先，我们来创建一个表示链表节点的类，通常命名为`Node`。这个类将包含两个属性：`data`用于存储数据，`next`用于指向下一个节点。 ``...
java单向链表的实现实例
09-04
在这个实例中，我们将详细讨论如何在Java中实现单向链表，包括创建节点、插入节点、显示链表、删除节点、清空链表以及获取链表中指定范围内的数据。 首先，我们定义一个名为`Node`的类来表示链表中的节点。这个类有...
java数组和链表底层-链表的底层原理和实现 数组和链表.pdf
04-18
Java数组和链表底层-链表的底层原理和实现 数组和链表 本文主要介绍了链表的底层原理和实现，包括链表的存储结构、链表的优缺点、链表的实现等内容。链表是一种物理存储单元上的非连续、非顺序的存储结构，数据元素...
Java实现的自定义链表
最新发布
06-27
在 Java 中，实现一个自定义的链表（如单链表或双链表）是一个非常好的练习。下面是一个单链表的完 整实现，包括基本的操作如插入、删除、查找和遍历。
java链表实现的例子
12-20
链表
JAVA链表实现类（数据结构学习）
12-14
JAVA链表实现类（数据结构学习）.chm
java实现链表
weixin_46972127的博客
03-18 5315
1、什么是链表 链表是一种数据结构，和数组同级别。Java中我们使用的LInkedList，其实现原理为链表，而ArrayList其实现原理为数组。链表在插入和删除时优势明显。 单链表是一种线性表，实际上由节点（Node）组成，可以把单链表想象成为一列火车，而组成单链表的每个节点想象成为一节车厢。节点中存储了节点的值（data）以及指向下一个节点的指针（Next）。 2、单链表的实现（增删查改） package LinkedList; // 车厢类 class Node { // 存储
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 932
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
Java 手写单链表
weixin_41914010的博客
04-14 497
Java 手写单向链表 SingleLinkedList.java package com.muxiaofei.veryday.entity; /** * 单链表 * @param <T> */ public class SingleLinkedList<T> { //链表大小 public int size; // 头节点（先初始化一下） public Node<T> head = new Node<>();
手写链表，简单实现LinkedList
Silenct_UZI的博客
04-12 577
简单实现LinkedList
使用Java快速手写一个基于链表的队列
rianple的博客
04-06 100
在上一篇博客【教你如何使用Java手写一个基于数组的队列】中已经介绍了队列，以及Java语言中对队列的实现，对队列不是很了解的可以我上一篇文章。那么，现在就直接进入主题吧。 这篇博客主要讲解的是如何使用单链表实现一个简单版的队列。单向链表队列是属于非循环队列，同时队列的长度是不受限制的，也就是说添加数据的速度比拉取数据的速度快时，队列的长度是无限增长的。单链队列其本质就是一个链表，只不过是在获取或添加数据的时候跟普通的链表有所区别，队列在获取数据的同时也将该节点删除，并且每次获取数据都是从表头获取，普通链表
java链表是一种数据结构.docx
03-13
在Java中，我们通过自定义类`classListNode`来实现链表。这种数据结构的核心是`ListNode`，它代表链表中的一个元素，包括两个关键部分：`intval`用于存储节点的数据，以及`ListNode`对象`next`，作为指向下一个节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值