数据结构(2):LinkedList和链表[1]

于 2024-09-08 21:05:54 发布
阅读量426 收藏 8
点赞数 18
分类专栏： 数据结构：用java描述 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh04101912138/article/details/142027187
版权

 下面我们来介绍一种新的数据结构，链表。

我们曾经讨论过顺序表。它的数据存储在物理和逻辑上都是有逻辑的。而我们今天要学习的链表，则在物理结构上非连续存储，逻辑上连续。

1.链表的认识

链表由一个一个的节点组成。

我们可以想象一列火车，每一节车厢都被前面一节拉着，也拉着后面一节（头尾除外）。

我们的链表与火车近似，我们可以将每一个节点当作一节车厢，它除了存储自己的数据之外，还能带领我们找到链接在它后面的一个节点，这样“一节一节”把所有数据串联起来。

单个节点是这样的结构：

地址指的是下一个节点的位置，这样，我们就可以像火车一样把他们串联起来：

（水平有限，意思到了即可）

链表也分很多种类，它可以是双向/单向，不带头/带头，非循环/循环。我们先着重讨论，单项不带头非循环链表。

2.单项不带头非循环链表的实现

同样我们也要先明白链表的实现，我们来先创建一个自己的SingleLinkedList类。

然后，我们来讨论对于节点的定义，我们需要再定义一个节点Listnode类，需要注意，它要被定义在链表这个类里面，它属于一个内部类。它里面要存放值和下一个节点地址，我们可以这样操作：

public class SingleLinkedList {
    static class Listnode{
        public int val;//节点值域
        public Listnode next;//下一个节点的地址

        public Listnode(int val) {
            this.val = val;
        }
    }
    public Listnode head;//表示当前链表头节点
}

这样我们就完成了对节点的定义，下面我们就要实现链表的各种操作。包括但不限于：创建链表、遍历链表、插入数据（头插/尾插）、删除所有值为k的节点、清空链表等等。同样，我们先把每个方法大的框架定义出来，再一个个实现。

public class SingleLinkedList {
    static class Listnode{
        public int val;//节点值域
        public Listnode next;//下一个节点的地址

        public Listnode(int val) {
            this.val = val;
        }
    }
    public Listnode head;//表示当前链表头节点

    //头插法
    public void addFirst(int data){
    }
    //尾插法
    public void addLast(int data){
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key){
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
    }
    //得到单链表的长度
    public int size(){
        return -1;
    }
    //清空链表
    public void clear() {
    }
    //遍历打印
    public void display() {}
}

creatlist():

首先我们可以手动创建链表，一个节点一个节点进行定义。它并不属于链表的方法，但可以帮助我们理解。我们先创建几个节点，给他们赋值，再用.next一个一个链接，具体可以这样实现：

 public void creatlist(){
        Listnode listnode1=new Listnode(1);
        Listnode listnode2=new Listnode(2);
        Listnode listnode3=new Listnode(3);
        Listnode listnode4=new Listnode(4);
        Listnode listnode5=new Listnode(5);

        listnode1.next=listnode2;
        listnode2.next=listnode3;
        listnode3.next=listnode4;
        listnode4.next=listnode5;

        this.head=listnode1;
    }

不要忘了设置头节点，那么相当于我们已经手动创建出来了一个链表。它大概是这样的：

那么我们的链表就是长这个样子，我们后续操作会基于这种结构进行讲解。

dispaly():

遍历链表，我们要做的就是打印当前节点的值，之后成功走到下一个节点，直到最后，我们可以定义一个新的节点对象，让它指向头节点，从头节点开始一步一步往后走，这样既不会改变头节点的指向，也不会改变链表本身的结构。

public void display() {
        Listnode cur=head;
        while(cur!=null){
            System.out.println(cur.val);
            cur=cur.next;//cur往后走
        }
    }

我们可以测试一下

public static void main(String[] args) {
        SingleLinkedList list=new SingleLinkedList();
        list.creatlist();
        list.display();
    }

这就证明向后一步一步走这个策略是没问题的，我们后续很多操作都要遍历链表，我们要始终贯彻这一思想。

插入数据--头插：

头插就是让插入的节点在最开头。我们要贯彻一件事，不管怎么插，头节点永远是第一个节点。那么我们的思想是先将值赋给一个新的节点，让这个节点指向原来的头节点，再改变头节点的指向，这样就可以将新节点与原来的链表连接起来，并且保证了头节点的正确性。

public void addFirst(int data){
        Listnode node=new Listnode(data);
        node.next=head;
        head=node;
    }

插入数据--尾插：

这个就会简单一些，我们只需要定义一个cur,让它从头开始往后走，当走到最后一个时（此时是cur.net==null!），把它和新节点连接起来就可以了。

 //尾插法
    public void addLast(int data){
        Listnode node=new Listnode(data);
        Listnode cur=head;
        while(cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }

插入数据--任意位置插入

首先我们要保证pos位置的合法性（头节点位置为0），然后当我们插入时，我们要记录前后两个节点的信息，我们要同时保证前面的可以连接上新节点，并且保证新节点可以连接上后面的，不改变链表的连贯性。所以，我们要找到插入节点的前一个节点的信息，才能方便操作。顺便，当index==0/index==size(),我们可以进行头插尾插，所以我们可以把获取链表长度这个方法写出来。

public void addIndex(int index,int data){
        Listnode node=new Listnode(data);
        Listnode cur=findIndexSubOne(index);
        if(index==0){
            addFirst(data);
            return;
        }
        if(index==size()){
            addLast(data);
            return;
        }
        cur.next=node.next;
        node.next=cur;
    }
    private Listnode findIndexSubOne(int index){
        //找到想要删除/插入节点位置的前一个节点
        Listnode cur=head;
        while(index-1!=0){
            cur=cur.next;
        }
        return cur;
    }
public int size(){
        Listnode cur=head;
        int cnt=0;
        while(cur!=null){
            cnt++;
            cur=cur.next;
        }
        return cnt;
    }

我们重点体会这样两行代码：

cur.next=node.next;
node.next=cur;

这两行是插入的关键。第一行是让新插入节点的后继是后面的节点，第二行则是改变前面节点的指向，指向新插入的节点，这样就既与前面链接，也与后面连上了，且没有改变结构，我们也就实现了中间节点的插入。

contains():

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

这个就很简单了，我们遍历一下一带而过就可以了。

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

remove():

删除分为两种，一种是删除第一次出现的关键字，一种是删除链表里所有的关键字的节点。它们的思想都是一样的。我们删除的思想是：找到要删除的关键字，把它跳过，就可以了。下面我们来实现一下：

 public void remove(int key){
        Listnode cur=head.next;
        Listnode pre=head;//要删除节点的前驱
        while(cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
                return；
            }else{
                pre=cur;
                cur=cur.next;
            }
        }
        //删除头节点
        if(head.val==key){
            head=head.next;
        }
    }
public void remove(int key){
        Listnode cur=head.next;
        Listnode pre=head;//要删除节点的前驱
        while(cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
            }else{
                pre=cur;
                cur=cur.next;
            }
        }
        //删除头节点
        if(head.val==key){
            head=head.next;
        }
    }

我们定义一个cur,一个prev，代表当前节点和它的前驱，如果cur走到了要删除的节点，就让prev.next=cur.next,进行跳过。如果没有，就让两“人”都往前走一步，直到最后。当然，这里没有考虑头节点被删除的情况，我们单独实现了一下。

clear():

最后是清空链表，很简单，直接让头节点为空就可以了，这样链表就不存在了。

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

那么我们就完成了，下面是完整的代码实现：

public class SingleLinkedList {
    static class Listnode{
        public int val;//节点值域
        public Listnode next;//下一个节点的地址

        public Listnode(int val) {
            this.val = val;
        }
    }
    public Listnode head;//表示当前链表头节点
    public void creatlist(){
        Listnode listnode1=new Listnode(1);
        Listnode listnode2=new Listnode(2);
        Listnode listnode3=new Listnode(3);
        Listnode listnode4=new Listnode(4);
        Listnode listnode5=new Listnode(5);

        listnode1.next=listnode2;
        listnode2.next=listnode3;
        listnode3.next=listnode4;
        listnode4.next=listnode5;

        this.head=listnode1;
    }
    //头插法
    public void addFirst(int data){
        Listnode node=new Listnode(data);
        node.next=head;
        head=node;
    }
    //尾插法
    public void addLast(int data){
        Listnode node=new Listnode(data);
        Listnode cur=head;
        while(cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        Listnode node=new Listnode(data);
        Listnode cur=findIndexSubOne(index);
        if(index==0){
            addFirst(data);
            return;
        }
        if(index==size()){
            addLast(data);
            return;
        }
        cur.next=node.next;
        node.next=cur;
    }
    private Listnode findIndexSubOne(int index){
        //找到想要删除/插入节点位置的前一个节点
        Listnode cur=head;
        while(index-1!=0){
            cur=cur.next;
        }
        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.next;
        Listnode pre=head;//要删除节点的前驱
        while(cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
                return;
            }else{
                pre=cur;
                cur=cur.next;
            }
        }
        //删除头节点
        if(head.val==key){
            head=head.next;
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        Listnode cur=head.next;
        Listnode pre=head;//要删除节点的前驱
        while(cur!=null){
            if(cur.val==key){
                pre.next=cur.next;
            }else{
                pre=cur;
                cur=cur.next;
            }
        }
        //删除头节点
        if(head.val==key){
            head=head.next;
        }
    }
    //得到单链表的长度
    public int size(){
        Listnode cur=head;
        int cnt=0;
        while(cur!=null){
            cnt++;
            cur=cur.next;
        }
        return cnt;
    }
    //清空链表
    public void clear() {
        this.head=null;
    }
    //遍历打印
    public void display() {
        Listnode cur=head;
        while(cur!=null){
            System.out.println(cur.val);
            cur=cur.next;//cur往后走
        }
    }
}

和顺序表一样，我们使用链表也不需要自己重新写，java已经帮我们写好了，我们只需要直接使用就可以了，下面我们来学习链表的使用。

3.单链表的使用

 public static void main(String[] args) {
        List<Integer>list=new LinkedList<>();
        list.add(1);//头插
        list.add(2);
        list.add(3);
        for( int x:list){
            System.out.println(x);
        }
    }

我们可以像这样对单链表对象进行构造，并使用其中的方法，方法大部分都与我们实现的没有太大区别。

4.小结

这篇文章我们主要讨论的是单链表的实现，其中定义cur节点进行遍历这个思想十分重要。单链表十分重要，我们下篇文章会找一些常见典型的单链表的题，通过对题目的的分析加深大家对单链表的印象。

时间幻灭‘
关注
  • 18
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】链表LinkedList
qq_61862008的博客
11-18 1089
链表以及LinkedList介绍
visual-linkedlist:可视化链表数据结构的React App
05-13
一个React App，用于可视化单链列表数据结构。 安装 安装套件 npm install 用法 运行开发服务器 npm start 控制项 添加到头-用户输入一个值并将其添加到链接列表的头。 特定于删除-用户输入与链接列表中的节点匹配...
【数据结构Java版】LinkedList与链表
m0_63372226的博客
10-19 777
一、什么是LinkedList二、LinkedList的模拟实现（1）合法LinkedList的要求（2）LinkedList实现的内容1.结点个数2.链表尾插元素3.链表头插元素4.指定下标插入元素5.删除指定下标结点6.删除指定元素7.获取指定下标元素8.设置指定下标元素9.从前往后获取指定元素下标10.从后往前获取指定元素下标11.判断是否包含指定元素12.清空链表13.判断链表是否为空三、LinkedList的使用（1）LinkedList的构造四、ArrayList与LinkedList的比较
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2544
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
【数据结构】链表（LinkedList）详解
flmz_Kk的博客
07-15 1840
使用Java实现链表的创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作
数据结构之LinkedList与链表
sniper_fandc的博客
03-22 1882
目录 1.LinkedList的特点和存在意义 2.LinkedList的简单使用 2.1.LinkedList的构造 2.2.常见方法 2.3.遍历 3.链表结构 4.简单实现 4.1单向无头不循环链表 4.2.双向无头不循环链表 5.ArrayList与LinkedList的不同 1.LinkedList的特点和存在意义 LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了...
数据结构之链表（LinkedList详解）
crazy_xieyi的博客
09-29 9024
LinkedList实现了List接口；LinkedList的底层使用了双向链表；LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问； LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)；ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。ArrayList顺序表在物理上和逻辑上都是连续的，但是在扩容的时候，可能会造成空间的浪费。而LinkedList在物理上不一定是连续的，在逻辑上是连续的。
【Java数据结构】LinkedList-链表
Carefree_State的博客
03-13 1485
此文章详细讲解数据结构：链表，以模拟LinkedList的视角去研究链表，学习单链表以及双向链表的基础知识，后续我们可以靠这些知识，进攻更难的oj题，更特殊的链表类型~
LinkedList数据结构链表
qq_43012298的博客
02-16 791
LinkedList在Java中是一个实现了List和Deque接口的双向链表。它允许我们在列表的两端添加或删除元素，同时也支持在列表中间插入或移除元素。在分析LinkedListLinkedList。
LinkedList和链表
2301_78804510的博客
04-21 1183
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
【数据结构】LinkedList与链表
m0_74336101的博客
07-21 997
LinkedList与链表主要内容
LinkedList:链表
03-13
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。...在Python中，我们还可以利用内置的数据结构和库函数，如`deque`，来简化链表的实现和操作，同时保持良好的性能。
java数据结构：顺序表+链表+栈+队+堆+二叉树+常见排序+map+set代码与板书
08-02
2.链表 (LinkedList): 概念: 由节点组成，每个节点包含数据和指向下一个节点的引用 3.栈 (Stack): 概念: 后进先出 (LIFO) 的数据结构 4.队列 (Queue): 概念: 先进先出 (FIFO) 的数据结构 5.堆 (Heap): 概念: 完全...
一个简单的链表（LinkedList）数据结构
08-23
一个简单的链表（LinkedList）数据结构。链表是一种常见的数据结构，它由一系列节点（Node）组成，每个节点包含数据部分和指向列表中下一个节点的链接（或引用）。 这个脚本定义了两个类：ListNode 和 LinkedList。...
数据结构(6.4_6)——拓扑排序
m0_65240792的博客
09-04 317
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
【数据结构】--时间和空间复杂度
2303_80341387的博客
09-03 525
两个标准来衡量：1. 时间复杂度 2. 空间复杂度。
数据结构可视化工具
最新发布
晴山の博客
09-04 312
前期疑问：未完待续。
数据结构：树与二叉树
2301_80744520的博客
09-04 862
树是n个结点的有限集。若n=0，称为空树；若n>0称为非空树，非空树有且仅有一个称之为根的结点。除根结点以外的其余结点可分成m个互不相交的有限集T1,T2,......Tm,每个有限集合本身又是一棵树，并且称为根的子树。我们可以根据下面这张图来理解。根结点：非空树中无前驱结点的结点。图中A就是根结点结点的度：结点拥有的子树。例如A结点拥有三棵子树，所以它的度为3深度：树种结点的最大层次，图中的树深度为4接下来我们介绍各个结点之间的关系：叶子：也是终端结点，即没有子树的结点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值