数据结构（JAVA）第二篇-----链表

最新推荐文章于 2023-01-07 20:35:30 发布
最新推荐文章于 2023-01-07 20:35:30 发布
阅读量368 收藏
点赞数 1
文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55916894/article/details/127043250
版权

引言

①链表也是一种线性表，那我们既然已经有了顺序表这种数据结构了，又发明链表干嘛呢？

首先，我们知道顺序表根本上讲就是一个数组，那么我们回顾一下顺序表的插入或删除，需要先遍历一遍数组，找到插入或删除的位置，然后进行插删操作，之后必须调整这之后所有元素的位置，这样下来时间复杂度为O（n^{2}），效率并不是很可观。

②那么，我们想想导致这一原因的因素是什么呢？

就是因为它是数组，它的内存空间物理上是连续的，所以我们每次增删数据，都必须考虑该位置后的元素的位置是否要做出相应的改变。所以，如果我们可以构造一个物理空间上不连续，但它们都具有某种特定关系的线性表不就可以解决这个效率问题了吗，于是有了链表。

链表的定义：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用（也说指针）链接次序实现的。

由于实际上的链表种类较多，根据带头和不带头，单向和双向，循环与非循环分类，可以分成八种，但本文篇幅有限，就介绍不带头单向非循环，不带头双向循环。

一、单链表

1.定义

顾名思义，就是只有一端指向的链表。

不带头结点的单向非循环链表

RT:

​

其中，每一个对象的next都存放的是逻辑上的下一个对象的地址。 

2.自定义一个单链表

创建一个MyLinkedList类

public class MyLinkedList {
    
    static class ListNode {
        public int val;//值

        public ListNode next;//引用链接

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;//头结点
}

addFirst

头插

public void addFirst(int data){
            ListNode cur = new ListNode(data);//new 一个需要插入的结点
            cur.next = head;//将新结点的next指向head
            head = cur;//让cur成为头结点
        }

addLast

尾插

如果你一开始有tail结点，那就十分容易：

public void addLast(int data) {
            tail.next = new ListNode(data);
            tail = tail.next;
        }

但没有tail结点也没关系，我们遍历一边即可，只是时间复杂度变为O（n），但也仍然高于顺序表的O（n^{2}）

RT:

public void addLast(int data) {
            if(head == null){
                head = new ListNode(data);
                return;
            }
            ListNode cur = head;
            while(cur.next!=null){
                cur = cur.next;
            }
            cur.next = new ListNode(data);
        }

addIndex(int index,int data)

在index下标前插入data

第一时间，依旧是判断index是否合法，那必须要用到size()函数，求出当前链表的长度。

public int size() {
        ListNode cur = this.head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

RT:

public boolean addIndex(int index, int data) {
        if (index == 0) {
            ListNode insert = new ListNode(data);
            insert.next = head;
            head = insert;
            return true;
        }
        if(index < 0 && index > size()){
            return false;
        }
        ListNode cur = head;
        while(index - 1 > 0){
            cur = cur.next;//找到要插入的前一个结点
            index--;
        }
        ListNode insert = new ListNode(data);
        insert.next = cur.next;
        cur.next = insert;
        return true;
    }

obtain

是否包含

RT:

public boolean contains(int key) {     
        ListNode cur = head;
        while(cur!=null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

remove

删除

RT:

public void remove(int key) {
        if(head == null){
            return;
        }
        if(head.val == key){
            head = head.next;
        }
        ListNode pre = head;//找到前结点
        while(pre.next != null){
            if(pre.next.val == key){
                break;
            }
            pre = pre.next;
        }
        ListNode cur = head;
        while (cur != null) {
            if(cur.val == key){
                pre.next = cur.next;
            }
            cur = cur.next;
        }
    }

removeAllKey

删除所有值为key的结点

由于与leetcode的203题一样，那我们直接做leetcode。

https://leetcode.cn/problems/remove-linked-list-elements/

具体思路：

1.定义两个结点，pre 和 cur，pre作为cur的前一个结点一直跟随cur，当遇到目标结点了，就直接pre.next = cur.next。

2.如此一来，我们把pre初始化为head，cur为head.next。然后将cur！=null作为判断条件，遍历一遍链表即可。

3.值得注意的是，如果把cur初始化为head.next，那么首结点就无法判断了，所以我们在末尾的时候，判断一次首结点是否是目标结点，那么就完成了。

public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        ListNode pre = head;
        ListNode cur = head.next;
        while(cur!=null){
            if(cur.val == val){
                pre.next = cur.next;
                cur = cur.next;
            }else {
                pre = cur;
                cur = cur.next;
            }
        }
        if(head.val == val){
            head = head.next;
        }
        return head;
    }
}

clear

清空

public void clear() {
        this.head = null;
    }

解释：这里将head置为空，那么head所引用的对象head.next将因为无人引用而被回收，同样head.next的回收，又导致了head.next.next被回收，这样依次回收，链表就被清空了。

二、双链表

1.模拟实现

双链表的实现与单链表差距不大，主要的变化就是多了一个pre结点。直接上代码：

public class Linkedlist2 {
    static class ListNode {
        int val;
        ListNode pre;
        ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode tail;
    //头插法
    public void addFirst(int data) {
        ListNode cur = new ListNode(data);
        if (this.head == null) {
            this.head = cur;
            this.tail = cur;
        } else {
            this.head.pre = cur;
            cur.next = this.head;
            head = cur;
        }
    }
    //尾插法
    public void addLast(int data) {
        if (head == null) {
            head = new ListNode(data);
            tail = head;
        } else {
            ListNode cur = new ListNode(data);
            tail.next = cur;
            cur.pre = tail;
            tail = cur;
        }
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        //1、判断Index位置的合法性

        //2、判断特殊位置，头插 和 尾插

        //3、找到index位置节点的地址
        if (index < 0 || index > size()) {
            throw new PosOutInedx("INDEX IS ILLEGAL");
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode find = this.head;
        ListNode cur = new ListNode(data);
        while (index > 0) {
            find = find.next;
            index--;
        }
        cur.pre = find.pre;
        cur.next = find;
        find.pre.next = cur;
        find.pre = cur;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
        }
        return false;
    }
    //删除第一次出现关键字为key的节点(注意链表的tail结点置空情况)
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            if(cur.val == key){
                if(cur == head){
                    head = head.next;
                    if(head==null){
                        tail = null;

                    }else {
                        head.pre = null;
                    }
                }else if(cur == tail){
                    tail = tail.pre;
                    tail.next = null;
                }else{
                    cur.pre.next = cur.next;
                    cur.next.pre = cur.pre;
                }
                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){
                        tail = null;
                    }else {
                        head.pre = null;
                    }
                }else if(cur == tail){
                    tail = tail.pre;
                    tail.next = null;
                }else{
                    cur.pre.next = cur.next;
                    cur.next.pre = cur.pre;
                }
            }
            cur = cur.next;
        }
    }
    //得到单链表的长度
    public int size() {
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        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;
        head = null;
        tail = null;
        while (cur != null) {
            ListNode curNext = cur.next;
            cur.pre = null;
            cur.next = null;
            cur = curNext;
        }
    }

小结

        正所谓 -- 基础不牢，地动山摇。虽然JAVA自带了自己的数据结构，但我们仍然需要在模拟实现上多下功夫，了解其底层的实现原理，多看源码，不仅可以加强自己的代码能力，也可以加深对数据结构这门学科的理解。

三、总结

        我们通过链表的模拟实现，不难发现，链表的头插尾插效率很高，可以做到O（1），即使是随机插入，最坏的情况也是O(N)，所以，当我们的实际需求是频繁的插入删除时，同时如果要使用线性结构，请毫不犹豫使用链表。

        但是，我们同样也发现了，如果我们要知道链表的第K个元素，我们必须去遍历它，而顺序表便没有这个烦恼，我们可以直接访问数组下标，在O（1）的时间复杂度内便可完成，所以，当我们实际需求是要查找，只要进行很少的插入删除操作时，最好使用顺序表。

以上便是本篇文章的全部内容。

todd1er
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 983
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
数据结构与算法java实战篇--链表
小马哥的博客
12-22 579
数据结构
《Java数据结构与算法》笔记-CH5-链表-2单链表，增加根据关键字查找和删除
proheart的专栏
06-24 3892
/** * Link节点 有数据项和next指向下一个Link引用 */ class Link { private int iData;// 数据 private double dData;// 数据 public Link next;// 下一个link节点的引用 public int getiData() { return iData; } public Link(in
Java：查找是否包含关键字key是否在单链表当中
yufy0528的博客
03-23 264
public boolean contains(int key){ Node cur = this.head; while (cur != null) { if (cur.data == key) { return true; } cur = cur.next;...
Java单链表内容删除第一次关键字为key的节点
wobuyaoshiye的博客
11-27 266
Java单链表内容删除第一次关键字为key的节点。 操作过程为以下几步。 1.如果删除的节点为头结点 则直接将头结点置为空。头结点的Next置为新的头结点 if(this.head.data == key) { this.head = this.head.next; return; } 2.如果被删除的节点是处于中间位置的节点。这...
java单链表实现
qq_45554677的博客
04-28 303
链表介绍: 链表实一种非常使用的数据结构，它解决了数组的一些缺点，如数组一经定义，数组的大小就固定了，但在实际开发中，我们可能不确定数组的大小，更多是后需要的是一种可以自动扩充的数据结构，而链表就可以很好的实现这一点，作为程序员，我们很多时候在坐的事可能就是增删改查，大家都知道数组的增加和删除都需要大量移动数组中的元素，所以数组在增加和删除方面效率偏低，而链表很好的解决了这个问题，链表不需要移动元...
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
Java-数据结构课设-链表实现通讯录管理系统
10-07

　第二个模块——Menu()的功能是：显示提示选单。 
　第三个模块——Quit()的功能是：退出选单。 
　第四个模块——Create()的功能是：创建新的数据记录。 
　第五个模块——Add()的功能是：增加新的数据记录...
Java算法篇-链表去重与合并.pptx.pptx
最新发布
12-18
在Java算法领域，链表是一种重要的数据结构，它在处理动态数据集合时具有较高的灵活性。本文将探讨如何在Java中实现链表的去重与合并，特别关注有序链表的操作。 首先，我们来理解链表的基本概念。链表不同于数组，...
数据结构Java实现----单向链表的插入和删除
weixin_43770982的博客
08-08 702
一、链表结构： （物理存储结构上不连续，逻辑上连续；大小不固定） 概念： 　　链式存储结构是基于指针实现的。我们把一个数据元素和一个指针称为结点。 　　　　数据域：存数数据元素信息的域。 　　　　指针域：存储直接后继位置的域。 　　链式存储结构是用指针把相互直接关联的结点（即直接前驱结点或直接后继结点）链接起来。链式存储结构的线性表称为链表。 链...
Java链表基础
qq_46638003的博客
01-07 2233
以上是对链表的基础操作,大部分都是通过遍历链表实现.
Java链表详解--通俗易懂(超详细,含源码)
热门推荐
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
Java数据结构-认识链表
weixin_55752048的博客
01-28 3581
一.链表的概念及结构 1.链表的概念 链表是一种物理存储结构上非连续的存储结构。数据元素中的逻辑顺序是通过链表中的引用链接次序实现的 2.链表的分类
Java链表（基本操作）
Java软贱攻城狮
01-28 3117
·链表是一种最为简单的数据结构，它的主要目的是依靠引用关系来实现多个数据的保存，下面代码以String字符串类型示例 class Node { private String data; private Node next; public Node(String data) { this.data = data; } public void setNext(Node next
Java链表的定义和使用
keep coding!!
08-31 788
使用java定义和使用链表
java链表基本概念
口耳戈是个生僻字
02-03 6535
链表是一种根据元素节点逻辑关系排列起来的一种数据结构。利用链表可以保存多个数据，这一点类似于数组的概念，但是数组本身有一个缺点—— 数组的长度固定，不可改变，在长度固定的情况下首选的肯定是数组，但是在现实的开发之中往往要保存的内容长度是不确定的，那么此时就可以利用链表这样的结构来代替数组的使用。       链表是一种最为简单的数据结构，它的主要目的是依靠引用关系来实现多个数据的保存，那么下面
Java中自定义单链表
qq_42512179的博客
09-06 1万+
首先我们先了解一下什么是链表：   链表是一种数据结构，它是一种物理存储单元上非连续，非顺序的存储单元，只是在逻辑上是连续的，链表逻辑形态和铁链相识，链表是由一系列结点组成，结点在运行时动态生成，每个结点由两部分组成及：存储数据元素的数据域，和存储下一个结点的地址的指针域，链表有易于插入，删除，存储空间灵活等优点，但是不允许随机存取。       回归正题，我们来了解一下什么是单向链表： 单...
Java实现链表
小仙女的博客
04-27 3万+
         单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。(逻辑地址相连，物理地址不相连） 我们来用java的内部类来实现单链表的创建 class Link{//一个链表类 publi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

todd1er

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

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

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

打赏作者

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

抵扣说明：

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

余额充值