链表

最新推荐文章于 2024-11-07 23:35:47 发布
最新推荐文章于 2024-11-07 23:35:47 发布
阅读量121 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nevergiveup12345/article/details/86521967
版权

线性数据结构

在这里插入图片描述# 链表为什么重要

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

链表Linked List

  • 数据存储在“节点”(node)中
  • 在这里插入图片描述优点：真正的动态，不需要处理固定容量的问题
    缺点：丧失了随机访问的能力

数组与链表的对比

  • 数组最好用于索引有语义的情况。index[2]
  • 最大的优点：支持快速查询
  • 链表不适合于有索引有语义的情况
  • 最大的优点：动态

coding

在这里插入代码片

链表的时间复杂度

  • 添加操作
    addLast(e) O(n)
    addFirst(e) O(1)
    add(index,e) o(n/2) = o(n)
  • 删除操作
    removeLast(e) O(n)
    removeLast(e) O(1)
    remove(index,e) O(n)
  • 修改操作
    set(index,e) O(n)
    contains(e) O(n)
    find(e) O(n)
    综上所述
    链表的 增删改查时间复杂度都是O(n)
    增删查的只对链表进行操作时间复杂度都是O(1)

coding

package arithmetic.LinkedList;

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

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

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


    //在链表的中间添加元素
    public void add(E e) {
        Node node = new Node(e);

    }


    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;

        //上面3句=下面一句
        prev.next = new Node(e, prev.next);

        size++;

    }

    //在链表中添加新的元素e
    public void addFirst(E e) {
        add(0, e);
        size++;
    }


    public void addLast(E e) {
        add(size, e);
    }


    //在链表的index（0-based）位置添加新的元素e
    //在链表中不是一个常用的操作。练习用：)
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed .Illegal index");
        }

        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（0-based）个位置的元素为e
    //在链表中不是一个常用的操作
    public void set(int index, E e) {

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed .Illegal index");
        }

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

    //查找链表中是否有元素e
    public boolean contains(E e) {
        Node node = dummyHead.next;
//        for(int i=0;i<size;i++){
//            if (node != null){
//                if (node.equals(e)){
//                    return true;
//                }else {
//                    node = node.next;
//                }
//            }
//        }
        while (node != null) {
            if (node.equals(e)) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();

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

    //从链表中删除index（0-based）位置的元素，返回被删除的元素
    public E remove(int index) {

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed .Illegal index");
        }

        Node prev = dummyHead;
        Node cur = prev.next;

        Node del = null;
        for (int i = 0; i <= index; i++) {

            if (i == index) {
                del = cur;
                prev.next = cur.next;
                cur.next = null;
                cur = null;
            }
            if (cur != null){
                prev = cur;
                cur = cur.next;
            }

        }

        size -- ;
        return del.e;

    }


    //从链表中删除第一个元素，返回删除的元素
    public E removeFirst() {
        return remove(0);
    }

    //从链表中删除最后一个元素，返回删除的元素
    public E removeEnd() {
        return remove(size - 1);
    }

}

package arithmetic.LinkedList;

public class LinkedListStack<E> implements Stack<E> {

    private LinkedList<E> linkedList;

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

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

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

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

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

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

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Stack : top ");
        stringBuilder.append(linkedList);
        return stringBuilder.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);
        }

        System.out.println("-----------");
        stack.peek();
        System.out.println(stack);
    }
}

package arithmetic.LinkedList;

public class LinkedQueue<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 LinkedQueue() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }


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

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

    @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 (tail == null)
            throw new IllegalArgumentException("Cannot dequeue from queue .");

        Node returnNode = head;

        System.out.println("head:   " + head);
        System.out.println("head.next:   " +head.next);
        System.out.println("head.returnNode:   " +head.next);
        System.out.println("---------------------------");

        head = head.next;
        returnNode.next = null;

        if (head == null) {
            tail = null;
        }
        size--;
        return returnNode.e;
    }

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

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

    public static void main(String[] args) {

        LinkedQueue<Integer> queue = new LinkedQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);
            if (i % 3 == 2) {
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

package arithmetic.LinkedList;


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

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

        linkedList.remove(1);
        System.out.println("--------");
        System.out.println(linkedList);

//        linkedList.removeEnd();
//        System.out.println("--------");
//        System.out.println(linkedList);
    }
}

GitHub地址

静态链表
Minix的博客
03-27 2329
静态链表 静态链表（static linked list）是用数组来表示单链表，用数组元素的下标来模拟单链表的指针。这种描述方法称为游标（cursor）实现法。 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。 在链表的指针实现中有两个重要的特点： 数据存储在一组结构体中，每一个结构体包含有数据以及指向下一个结构体的指针； 一个新的结构体可以通过调用 malloc() 函数从系统全局内存得到，并可通过调用 free() 函数而被释放。 游标法必须能够模
C++ 链表
热门推荐
m0_62175410的博客
07-26 3万+
C++链表笔记
Python链表
sikh_0529的博客
09-12 1万+
链表是一系列数据元素，通过链接连接在一起。 每个数据元素都以指针的形式包含到另一个数据元素的连接。 Python在其标准库中没有链接列表。 我们使用前一章讨论的节点概念来实现链表的概念。 我们已经知道如何创建节点类以及如何遍历节点的元素。 在本章中，将学习链表的类型:单链表。 在这种类型的数据结构中，任何两个数据元素之间只有一个链接。 创建一个链表并使用一些方法来插入，更新和从列表中移除元素。通过使用在上一章中学习的节点类来创建链表。创建一个对象并创建另一个类来使用这个节点对象。 通过节点对象传递适当的值来
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
PTA 两个有序链表序列的合并
10-07
在编程领域，有序链表序列的合并是一个常见的问题，尤其在数据结构和算法的学习中占有重要地位。这个题目“PTA 两个有序链表序列的合并”主要涉及到链表的操作和合并策略，这对于理解和掌握链表操作有极大的帮助。...
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
《数据结构与算法》二叉树基础OJ练习
2301_79722165的博客
11-05 246
学习了二叉树之后，来做点关于二叉树的基础题
【算法与数据结构】【链表篇】【题1-题5】
handsomethefirst的博客
11-07 594
题目：输入一个链表的头结点，从尾到头反过来打印出每个节点的值。思路：要反过来打印，首先需要遍历，那么从先遍历的节点后打印，典型的后进先出，符合栈的结构。
数据结构(C语言版)-1.线性表
yang_pi_pi的博客
11-07 850
胡元义，黑新宏 数据结构教程-》 第2章 线性表
【初阶数据结构篇】链式结构二叉树（二叉链）的实现（感受递归暴力美学）
braveact的博客
11-04 1219
按照规则，⼆叉树的遍历有：前序/中序/后序的递归结构遍历：1）前序遍历(Preorder Traversal 亦称先序遍历)：访问根结点的操作发⽣在遍历其左右⼦树之前访问顺序为：根结点、左⼦树、右⼦树2）中序遍历(Inorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之中（间）访问顺序为：左⼦树、根结点、右⼦树3）后序遍历(Postorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之后访问顺序为：左⼦树、右⼦树、根结点。
数据结构C语言描述2(图文结合)--有头单链表，无头单链表(两种方法)，链表反转、有序链表构建、排序等操作，考研可看
最新发布
weixin_74085818的博客
11-07 749
链表由一系列不必存在内存中连续的空间的结构组成；每一个结构都有包含元素的`数据域`和指向下一个节点的`指针域`，指针域存储指向下一个节点的指针，最后一个元素的指针指向为`NULL`。
数据结构计算二叉树节点的个数
qq_45153375的博客
11-07 201
因此，这棵树中度为0的节点数 ( n_0 = 4 )，度为1的节点数 ( n_1 = 3 )。因此，这棵树中度为0的节点数 ( n_0 = 6 )，度为2的节点数 ( n_2 = 5 )。因此，这棵树的总节点数是 18，度为2的节点数 ( n_2 = 7 )。以下是几道练习题帮助理解如何计算度为1和度为0的节点数量。
数据结构 | 第四章 | 栈和队列
ZJC744575的博客
11-07 190
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出。：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。LIFO（Last In First Out）的原则。：栈的插入操作叫做进栈/压栈/入栈，：栈的删除操作叫做出栈。
数据结构---排序总结
深夜敲代码
11-07 114
O(n^2)：冒泡排序，选择排序，插入排序。O(n * log(n))：堆排序，快速排序，归并排序。O(n^1.3)：希尔排序2.空间复杂度：O(n)归并排序O(log(n)) ~ O(n)：快速排序O(1)：冒泡排序，选择排序，插入排序，堆排序，希尔排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值