数据结构-链表

最新推荐文章于 2025-06-14 15:30:38 发布
最新推荐文章于 2025-06-14 15:30:38 发布
阅读量126 收藏
点赞数 1
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39485901/article/details/120298304
版权
本文探讨了链表作为动态数据结构的基础概念，涉及指针理解、递归运用，以及其在栈、队列等数据结构中的实现。重点介绍了链表的时间复杂度和常见操作，如添加、删除和查找。并通过实例展示了链表栈和队列的实现与测试。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

4、链表

4.1 线性数据结构

底层依托静态数组，靠resize解决固定容量问题

  • 动态数组
  • 栈
  • 队列

真正的动态数据结构

  • 链表，不需要处理固定容量大的问题

4.2 链表的重要性

  • 更深入的理解引用（或者指针）
  • 更深入的理解递归
  • 最简单的动态数据结构
  • 辅助组成其他数据结构

4.3 链表

  • 数据存储在节点Node中

    class Node{
	E e;
	Node next;
}

在这里插入图片描述

  • 丧失了随机访问的能力
  • 数组和链表的对比
    • 数组最好用于索引有语义的情况，最大的优点是支持快速查询
    • 链表不适合具有索引语义的情况，最大的优点是动态
  • 链表的时间复杂度分析：
    • 添加addLast：O(n)
    • 添加addFirst：O(1)
    • 添加add(e,index)：O(n/2) = O(n)
    • 删除removeLast：O(n)
    • 删除removeFirst：O(1)
    • 删除remove(e,index)：O(n/2) = O(n)
    • 修改set(index)：O(n)
    • 查contains(e)：O(n)
    • 查find(e)：O(n)

4.4 链表的实现

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;
    private int size;

    public LinkedList() {
        //初始化虚拟头结点
        dummyHead = new Node(null,null);
        size = 0;
    }

    public int getSize() {
        return size;
    }

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

    //在链表中间添加元素
    public void add(E e, int index) {
        if(index <0 || index > size) {
            throw new IllegalArgumentException("add failed");
        }

        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 E remove(int index) {
        if(index <0 || index > size) {
            throw new IllegalArgumentException("remove failed");
        }

        Node prev = dummyHead;
        for(int i = 0;i<index; i++) {
            prev = prev.next;
        }
		
        Node ret = prev.next;
        prev.next = ret.next;
        ret.next = null;
        size--;
        return ret.e;
    }

    public E removeFirst() {
        return remove(0);
    }

    public E removeLast() {
        return remove(size -1);
    }

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

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

    //获取链表中的第index元素
    public E get(int index) {
        if(index <0 || index > size) {
            throw new IllegalArgumentException("get failed");
        }

        //从第一个元素开始遍历
        Node cur = dummyHead.next;
        for(int i=0; i<index;i++) {
            cur = cur.next;
        }

        return cur.e;
    }

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

    public E getLast() {
        return get(size - 1);
    }

    //修改链表的第index元素
    public void set(E e, int index) {
        if(index <0 || index > size) {
            throw new IllegalArgumentException("set failed");
        }

        Node cur = dummyHead.next;
        for(int i = 0;i<index; i++)
            cur = cur.next;
        cur.e = e;
    }

    //查找链表中是否有元素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;
    }
    
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node cur = dummyHead.next;
        while(cur != null) {
            res.append(cur+"->");
            cur = cur.next;
        }
        res.append("Null");
        return res.toString();
    }
}

4.5 链表测试

public class Main{
    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);
        }

        linkedList.add(666,2);
        System.out.println(linkedList);

        linkedList.remove(2);
        System.out.println(linkedList);

        linkedList.removeFirst();
        System.out.println(linkedList);

        linkedList.removeLast();
        System.out.println(linkedList);
    }
}

4.6 基于链表实现栈

public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> linkedList;

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

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

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }
	
    //入栈操作
    @Override
    public void push(E e) {
        linkedList.addFirst(e);
    }
	
    //出栈操作
    @Override
    public void pop() {
        return linkedList.removeFirst();
    }
	
    //得到栈顶元素
    @Override
    public E peek() {
        return linkedList.getFirst();
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("top: ");
        stringBuilder.append(linkedList);
        stringBuilder.append(" :end");
        return stringBuilder.toString();
    }
}

4.7 测试链表栈

public class Main{
    public static void main(String[] args) {
        //测试链表栈
        LinkedListStack<Integer> linkedListStack  = new LinkedListStack<>();
        for(int i = 0; i <5; i++) {
            linkedListStack.push(i);
            System.out.println(linkedListStack);
        }
        linkedListStack.pop();
        System.out.println(linkedListStack);
    }
}

4.8 测试对比链表栈与数组栈

两者消耗时间差不多

public class Main{
    public static void main(String[] args) {
        int opCount = 1000000;
        double time1 = testStack(new ArrayStack<>(opCount),opCount);
        double time2 = testStack(new LinkedListStack<>(),opCount);
        System.out.println(time1);
        System.out.println(time2);
    }
    
    public static double testStack(Stack<Integer> s, int opCount) {
        long startTime = System.nanoTime();
        Random random = new Random();
        for(int i = 0; i < opCount; i++) {
            s.push(random.nextInt(Integer.MAX_VALUE));
        }

        for(int i =0; i<opCount; i++) {
            s.pop();
        }
        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }
}

4.9 基于链表实现队列

链表实现队列的思想是在链表的首尾各添加一个指针，指向第一个节点和最后一个节点。这种设计思路原因是，链表取出第一个元素的复杂度为O(1)，给链表添加一个尾指针指向尾元素后，添加元素复杂度为O(1)，结合这两点正好可以分别利用到队列的出队与入队操作。其大致思想如下图所示：

在这里插入图片描述

实现方法：

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 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }
	
    //链表尾端添加元素
    @Override
    public void enqueue(E e) {
        //当链表没有元素时，要新建一个节点
        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("deque failed");
        }

        Node node = head;
        head = head.next;
        node.next = null;
        //当链表中只有一个元素时，删除第一个节后，就没有节点了，此时tail需要指向null
        if(head == null) {
            tail = null;
        }
        size--;
        return node.e;
    }

    @Override
    public E getFront() {
        if(isEmpty()) {
            throw new IllegalArgumentException("deque failed");
        }
        return head.e;
    }

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

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

4.10 测试链表队列

public class Main{
    public static void main(String[] args) {
        //测试链表队列
        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
        for(int i=0; i<10; i++) {
            linkedListQueue.enqueue(i);
            System.out.println(linkedListQueue);
            if(i%3 == 2) {
                linkedListQueue.dequeue();
                System.out.println(linkedListQueue);
            }
        }
    }
}
数据结构-链表结构-双向链表
陆卿之的博客
08-01 4198
双向链表
java数据结构-链表详解
m0_63526467的博客
05-04 4345
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
C语言数据结构-链表的基本操作（超详细）
2301_79975618的博客
01-17 1万+
目录：1.单链表的分类；2.单链表的操作；3.代码详解；4.完整代码展示；一：单链表的分类总体上来说，单链表可以分为两大类，一种是带头结点的，另一种是不带头结点的（如果分细来讲，链表的插入可以分为两种：头插法和尾插法。二：单链表的操作1.单链表的初始化；2.单链表的头插法；3.单链表的尾插法；4.删除元素；5.遍历链表；
数据结构 -- 链表详解
hu_143的博客
04-27 3420
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构-链表篇
热门推荐
qq_16268979的博客
01-10 1万+
数据结构-链表篇
数据结构-链表（代码详解）
hcx009的博客
04-23 2414
数据结构与算法——线性表（链表篇）_线性链表-优快云博客，但是这篇博客不能细看，也不能深究，因为错误和纰漏太多了，包括但不限于变量名的错误，函数传参的误导性，以及部分知识点错的离谱，本文也只是跟着这篇博客整理的知识点的结构来自己写的代码，毕竟：Talk is cheap, show me the code.//1.//2.//这里的typedef是取别名的意思//把 struct LNode取个简单的名字为 LNode。
数据结构——链表
2301_76227083的博客
09-11 6771
学习了顺序表就知道，顺序表在大量的头插或者中间插入的时候效率是很低的，需要频繁挪动数据，那么有没有一种数据结构在处理大量头插和中间插入的时候效率非常高呢？是有的，今天我们就来学习一下链表。
数据结构----链表
新手嵌入式学习的博客
08-16 2469
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构 - 链表
qq_43629857的博客
06-16 6617
线性表的链式存储结构 - 链表
C语言数据结构-链表版学生管理系统
10-02
《C语言数据结构-链表版学生管理系统》 在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版...
数据结构-链表简要介绍.pdf
03-13
链表是一种基础的数据结构，它不同于数组，其元素在内存中不是连续存放的，而是通过节点间的指针连接构成一个序列。链表中的每个节点包含两部分信息：一个是数据域，用于存储数据元素；另一个是指针域，用于存放指向...
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构-链表相关c++代码-k个一组翻转链表
03-20
数据结构-链表相关c++代码-k个一组翻转链表
数据结构 学习 图 2025年6月14日 12点57分
最新发布
梦境虽美,却不长.
06-14 454
强连通：在有向图中，如果从顶点u到v有一条路径，且从v到u也有一条路径，则称u和v强连通强连通分量：有向图的极大强连通子图关节点（割点）：删除该顶点会增加图的连通分量数量桥（割边）：删除该边会增加图的连通分量数量双连通分量：不含关节点的极大连通子图欧拉回路：图中经过每条边恰好一次并回到起点的闭合路径欧拉路径：图中经过每条边恰好一次的路径（不一定闭合）欧拉图：存在欧拉回路的图半欧拉图：存在欧拉路径但不存在欧拉回路的图哈密尔顿路径：经过图中每个顶点恰好一次的路径哈密尔顿回路：闭合的哈密尔顿路径（起点=终点）
数据结构 - 栈与队列
Xingshi89的专栏
06-09 260
栈又称为后进先出的线性表（Last In First Out , LIFO）。是一种先进先出的线性表（First In Fist Out , FIFO）。它只允许在表的一端进行插入，而在另一端删除元素。：限定仅在表尾进行插入或删除操作的。在队列中，允许插入的一端称为。表尾端有特殊含义，称为。，允许删除的一端则称为。
【数据结构】图算法（代码）
m0_73911405的博客
06-10 1287
这里我用的上一章节中图的邻接矩阵的结构，进行遍历的。这里其实跟二叉树中，层序遍历思想差不多，都是前一个节点带后面的节点(A带B,C,D之后依次类推)当然这里有一个难点就是当我们遍历到B的时候我们插入队列的时候有AEC，但是我们只想要E，因为A已经pop掉了，C在队列中。我们该如何操作？用个数组标记一下全部元素，当前要插入队列中的元素是否用过，也就是说当我们元素插入到队列的时候标记一下。代码理解一下测试结果。
用Java实现常见排序算法详解
m0_66884848的博客
06-13 883
本文介绍了6种常见排序算法的Java实现，包括冒泡、选择、插入排序等基础算法，以及快速、归并、堆排序等高效算法。对每种算法从基本思想、时间复杂度分析和Java代码实现三个方面进行详细说明，展示了排序算法的核心逻辑和性能特点。这些排序方法在计算机科学中具有广泛应用，理解其原理和实现有助于提升编程能力和算法思维。
详解快排的四种方式
jingfeng514的博客
06-09 1032
快速排序是Hoare于1962年提出的⼀种⼆叉树结构的交换排序⽅法，其基本思想为：任取待排序元素 序列中的某元素作为基准值，按照该排序码将待排序集合分割成两⼦序列，左⼦序列中所有元素均⼩ 于基准值，右⼦序列中所有元素均⼤于基准值，然后最左右⼦序列重复该过程，直到所有元素都排列 在相应位置上为⽌。
数据结构-链表合并示例与算法解析
"这篇资料主要讨论的是数据结构中的节点合并问题，特别提到了在合并值为-7和-2的节点后的链表状态，并给出了相关的算法说明和数据结构的教材及参考文献。" 在数据结构中，节点合并是常见的操作，特别是在处理链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值