【数据结构】——链表

已于 2022-08-28 17:14:15 修改
阅读量370 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-08-19 17:43:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62678196/article/details/126402894
版权

前言：我们学习顺序表时会发现有点问题：

  1. 在顺序表中间或者头部的插入和删除，时间复杂度为O(N)
  2. 在增容时会浪费一定的的空间，并且增容需要申请新的空间拷贝数据，释放旧的空间，也会有不小的消耗。

为了解决这些问题，我们便来学习链表。

 一、认识链表

链表是一种物理存储结构上的非连续存储结构,数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

首先介绍的是无头单向链表,其结构如下图

 二、链表的实现（无头单向非循环链表）

  • 构造静态内部类
static class Node{
        public int val;
        public Node next;
        public Node(int val){
            this.val = val;
        }
    }
    public Node head;
  • 头插法
 public void addFirst(int data){
        Node node = new Node(data);
        node.next = head;
        head = node;
    }
  • 尾插法
public void addLast(int data){
        Node node = new Node(data);
        if (head == null){
            head = node;
        }else {
            Node cur = head;
            while (cur.next != null){
                cur = cur.next;
            }
            cur.next = node;
        }
    }

  • 任意位置插入,第一个数据节点为0号下标

private void checkIndex(int index){
        if(index < 0 || index > size()){
            throw new IndexNotLegalException("index位置不合法");
        }
    }
    public void addIndex(int index,int data){
        checkIndex(index);
        if (index == 0){
            addFirst(data);
            return;
        }
        if (index == size()){
            addLast(data);
            return;
        }
        Node node = new Node(data);
        Node cur = findIndexSubOfOne(index);
        node.next = cur.next;
        cur.next = node;
    }

    private Node findIndexSubOfOne(int index) {
        Node cur = head;
        while (index-1 != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }

  • 查找是否包含关键字key是否在单链表当中

public boolean contains(int key){
        Node cur = head;
        while (cur != null){
            if (cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
  •  删除第一次出现关键字为key的节点
public void remove(int key){
        if (head == null){
            System.out.println("链表为空,不能进行删除!");
            return;
        }
        if (this.head.val == key){
            head = head.next;
            return;
        }
        Node cur = this.head;
        while (cur.next != null){
            if (cur.next.val == key){
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
    }

  • 删除所有值为key的节点

public void removeAllKey(int key){
        if (this.head == null){
            return;
        }
        Node cur = this.head.next;
        Node prev = this.head;
        while (cur != null) {
            if (cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        if (this.head.val == key) {
            head = head.next;
        }
    }
  • 得到单链表的长度
public int size(){
        Node cur = head;
        int count = 0;
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }
  • 清空链表
public void clear(){
        //this.head = null;
        Node cur = head;
        Node curNext = null;
        while (cur != null){
            curNext = cur.next;
            cur.next = null;
            cur = curNext;
        }
        head = null;
    }

 三、LinkedList的模拟实现

LinkedList底层就是一个双向链表，我们来实现一个双向链表。

public class LinkedList {

    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

        public ListNode head;
        public ListNode last;

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (head == null){
            head = node;
            last = node;
        }else {
            node.next = head;
            head.prev = node;
            head = node;
        }
    }
    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null){
            head = node;
            last = node;
        }else {
            last.next = node;
            node.prev = last;
            last = last.next;
        }
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        if (index < 0 || index > size()){
            System.out.println("index不合法!");
            return;
        }
        if (index == 0){
            addFirst(data);
            return;
        }
        if (index == size()){
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndex(index);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }
    private ListNode findIndex(int index){
        ListNode cur = head;
        while (index != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null){
            if (cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null){
            if (cur.val == key){
                //处理头部问题
                if (cur == head){
                    head = head.next;
                    if (head != null) {
                        //防止只有一个节点
                        head.prev = null;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if (cur.next != null){
                        //删除的不是尾巴节点
                        cur.next.prev = cur.prev;
                    }else {
                        //删除的是尾巴节点
                        last = cur.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key) {
        ListNode cur = head;
        while (cur != null){
            if (cur.val == key){
                //处理头部问题
                if (cur == head){
                    head = head.next;
                    if (head != null) {
                        //防止只有一个节点
                        head.prev = null;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if (cur.next != null){
                        //删除的不是尾巴节点
                        cur.next.prev = cur.prev;
                    }else {
                        //删除的是尾巴节点
                        last = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }
    //得到单链表的长度
    public int size() {
        ListNode cur = head;
        int count = 0;
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }
    public void display() {
        ListNode cur = head;
        while (cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    public void clear() {
        ListNode cur = head;
        while (cur != null){
            ListNode curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
        head = null;
        last = null;
    }

}

 3.2 LinkedList的使用

  • 其常用的方法: 

 3.3 LinkedList的遍历

1、foreach遍历：

public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        // foreach遍历
        for (int e:list) {
            System.out.print(e + " ");
        } System.out.println();
}

2、使用迭代器遍历

public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
    
        // 使用迭代器遍历---正向遍历
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+ " ");
        } System.out.println();

        // 使用反向迭代器---反向遍历
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
            System.out.print(rit.previous() +" ");
        } System.out.println();
    }

四、ArrayList和LinkedList的区别

  1. 存储方式：顺序表使用的是一块连续的地址来存储数据，所以相邻数据的地址也是相邻的。而链表不需要使用连续的地址（这是链表的优点之一）。
  2. 使用场景：如果数据频繁的进行插入和删除的情况下，使用LinkedList来实现（）；如果数据频繁的进行查询修改和高效存储的情况下，使用ArrayList来实现。
  3. 空间扩容：ArrayList在空间不够得到情况下需要进行扩容处理，而LinkedList没有容量的概念。
  4. 在头插时：ArrayList的时间复杂度为O(N)，LinkedList得到时间复杂度为O(1)。
  5. 随机访问：ArrayList支持，O(1)，LinkedList不支持随机访问。
玫瑰永不凋零呀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
链表及索引
KwokWyman的博客
07-28 1025
链表中数据单位的名称叫做“结点”，结点和结点的分布在内存中可以是的。相对于数组来说，链表添加和删除元素都不需要挪动多余的元素高效的增删明确插入/删除的目标位置，只需要改变目标结点及其前驱/后继结点的指针指向麻烦的访问试图读取某一个特定的链表结点时，必须遍历整个链表来查找它在数组中直接访问索引可以做到一步到位。...
进程的组织方式：链接方式和索引方式
mariodf的博客
07-18 550
进程的组织方式链接方式和索引方式。
【MySQL】索引原理（一）：索引的存储结构是什么？数组？链表？树？
A minor
10-28 3973
索引是什么？ 维基百科对数据库索引的定义：数据库索引，是数据库管理系统（DBMS）中一个排序的数据结构，以协助快速查询、更新数据库表中数据 怎么理解这个定义呢？ 首先数据是以文件的形式存放在磁盘上面的，每一行数据都有它的磁盘地址。如果没有索引的话，要从500万行数据里面检索一条数据，只能依次遍历这张表的全部数据，直到找到这条数据。 但是有了索引之后，只需要在索引里面去检索这条数据就行了，因为它是一种特殊的专门用来快速检索的数据结构，我们找到数据存放的磁盘地址以后，就可以拿到数据了。 就像我们从一本50
3.数据结构单链表之链表索引
Jeremy_Ren的博客
12-21 6084
上两篇博文已经介绍完单链表的整表的创建，下面来介绍以下单链表的索引： 1.首先还是通过尾插法来创建一个单链表，用以下函数：listnode CreatlistTail(listnode* L, int a[], int len) { listnode* r = L; for (int i = 0; i < len; i++) { listnode* trans =
【数据结构】链表的基础知识简介
zsc19990913的博客
02-16 484
写在前面：配合leetcode题目效果更好。 一些需要注意的知识点。 头结点的值是没有意义的； 判断带有头结点链表为空的条件是head.next==None 关于链表的操作都可以概括为：判断操作是否有意义（长度）——找到指定位置——进行操作； 文章目录一、插入结点二、删除元素三、创建单链表3.1 尾插法创建单链表3.2 头插法创建单链表四、双链表五、循环链表 一、插入结点 带有head和不带有head相比，前者在实际应用中要简单很多，后者需要定义head为gobal变量。 将元素插入带有头结点的链
索引的数据结构（3）
最新发布
一个菜鸡的博客
09-29 446
每一棵B+树的每一个节点都是一个数据页B+树每 层节点都是按照索引列的值 从小到大的顺序排序 而组成了 双向链表而增、删、改操作可能会对节点和记录的排序造成破坏，所以存储引擎需 要额外的时间进行一些 记录移位 ， 页面分裂 、 页面回收 等操作来维护好节点和记录的排序如果 我们建了许多索引，每个索引对应的B+树都要进行相关的维护操作，会给性能拖后腿。
算法和数据结构——链表.pdf
08-07
#资源达人分享计划#
数据结构——链表的实现
12-29
数据结构课程的链表类的C++实现，搜索，删除，插入，查找等函数
数据结构——链表的创建、插入、删除.pdf
08-07
#资源达人分享计划#
数据结构——链表合并
08-09
"链表合并"是一个常见的数据结构问题，特别是在处理动态数据集合时。本文将深入探讨链表合并的概念，以及如何通过C++来实现这个过程。 链表是一种线性数据结构，不同于数组，它的元素（节点）在内存中并不连续存放...
跳表的原理
诗和远方，代码和你
07-28 1089
跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。...
【Java】轻松掌握链表操作
叮当猫的博客
03-25 2214
基于节点的数据结构——链表1.1 什么是链表1.2 链表的读取与查找1.3 链表的插入1.4 链表的删除1.5 链表 vs 数组 1.1 什么是链表 在数组存储的过程中，数组的存储必须使用连续的内存空间，并且会预留一部分空间方便扩展。这样在内存中会大大降低内存的使用率，这种事情是不被接受的。所以出现了一种新的数据结构，叫作——链表 综上可知：链表的发明其实是对数组的一种补充。因此它的功能和数组非常类似，都是用于存储一系列相同类型的数组，并且都有增删改查等基本操作 用一句话来总结： 数组能做的所有事情，一般
一张图对比文件顺序分配、链接分配、索引分配
gszhlw的博客
04-17 2643
其中，链接分配中的显式链接分配与索引分配在描述上有一些让人觉得分不清区别，后来认为显示链接分配只是将指针信息按照先后顺序记录在FAT中，解决的隐式链接无法随机访问的问题，但是在逻辑上还是顺序的记录磁盘块的信息。索引分配在逻辑上更像是包含关系，因为他的索引块记录的是顶层索引块，顶层索引块中记录的是一级索引块，而一级索引块中又记录的是（若有）耳机索引块。 ...
数组和链表
m0_37634615的博客
06-17 402
数组和链表 文章目录数组和链表剖析数组和链表的区别1.长度2.索引3.新增4.删5.改6.查7.内存分配数组的声明1.静态声明 说到数组和链表，一般会从长度、索引、增删改查的效率、内存分配等方面去剖析他们的区别。 剖析数组和链表的区别 1.长度 数组的长度是固定的，声明一个数组后长度就是固定的了；而链表是链式存储，可以随之延长。 2.索引 数组有索引，数组内每个元素的位置是有一个唯一的索引，并且有序；而链表虽说也是有序，但是没有索引，并不能知道某个节点在链表 3.新增 增：数组中新增一个元素的时候，必须
数组链表合体 - 链式数组结构！集合链表和数组的优点于一身，一百万数据的随机添加以及随机删除最快只需 2.2 秒，是 ArrayList 的 70 倍 ！
kfyty725的博客
10-01 949
一种新的数据结构 - 链表数组结构！集合链表和数组的优点于一身，一百万数据的随机添加以及随机删除最快只需 4.5 秒！ 简介及测试结果 我们都知道，java 中最常用的集合是 ArrayList、LinkedList，前者是数组实现的，后者是双向链表实现的。 对于 ArrayList 来说适合读多写少的场景，因为它写数据的时候需要扩容或者移动数据； 对于 LinkedList 来说则适合写多读少的场景，因为它读数据的时候需要对节点进行遍历。 那么问题来了，有没有一种数据结构能够综合这两种数据结构的优点呢？
线性表的数组实现
dianlu7964的博客
05-04 2262
分别实现3种类型的链表，这一篇用数组来实现线性表--- 有序链表：链表元素或节点始终保持有序，链表元素为Comparable对象，主要体现在插入操作要插入在相应的序列位置 无序链表：无序，每次指定插入在哪（表头，尾，or指定元素之后） 索引链表：提供了许多与索引相关的操作 将三种实现的都有的公共操作定义在一个接口ADT中，对应于各自特征所特有的操作扩展在自己的类中，可以看到，其实...
【数据结构】链表
程序员小潘
06-29 709
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 链表也是属于「线性表」的一种，它和数组最大的区别就是数据元素无需存储在一块连续的内存空间里。内存空间不连续了，那该如何判断元素之间的前后顺序呢？ ​ 链表要求每个节点除了保存数据元素本身，还需要包含一个或多个额外的指针，来指向它关联的元素，元.
数据结构——数组与链表
weixin_61015911的博客
04-30 2373
数据结构——数组与链表一、数组理论基础二、链表理论基础1.链表分类1）单链表2）双链表3）循环链表4）块状链表2.链表的存储方式3.链表的定义4.链表的操作1）删除节点2）插入节点3）查找元素4）更新元素5.虚拟头节点的使用6.与数组的对比 一、数组理论基础 数组是存放在连续内存空间上的相同类型数据的集合。可以方便的通过下标索引的方式获取到下标下对应的数据。 不能单独删除、释放数组中的某个元素，只能覆盖。如果要释放，就是全释放（程序运行结束，回收内存栈空间）。 因为数组的在内存空间的地址是连续的，所以我们在
01基础数据结构之链表
09-14
链表是一种基本的数据结构，它是由一系列节点组成的数据结构，其中每个节点包括数据元素和指向下一个节点的指针。与数组不同的是，链表的节点可以存储在内存的任何位置，并且它们通过指针相互连接在一起，而不需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值