链表 Linked List——单链表的讲解和实现

最新推荐文章于 2022-11-02 12:34:47 发布
最新推荐文章于 2022-11-02 12:34:47 发布
阅读量537 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52567278/article/details/124080495
版权

3.1 链表（Linked List）介绍

  • 链表是有序的列表，在逻辑结构上是有序的，但它在内存中的物理结构是乱序的 在这里插入图片描述

小结：

  • 链表是以节点的方式来存储，属于链式存储

  • 每个节点包含 data域：存储数据，next域：指向下一个节点

  • 链表的各个节点不一定是连续存储

  • 链表分为 带头结点的链表 和 不带头结点的链表，根据实际需求确定

在这里插入图片描述

3.2 单链表的应用实例

使用带head头的单向链表实现：

​ 水浒英雄排行榜管理，完成对英雄的增删改查操作

​ 步骤：

  1. 第一种方法在添加英雄时，直接添加到链表的尾部，思路如下：

  • 添加（创建）：

    先创建一个head头结点，用来表示单链表的头

    后面每添加一个节点，就直接加入到链表的最后

  • 遍历：

    通过一个辅助变量遍历整个链表，寻找链表尾部

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FrK32X2X-1649578788902)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220410154449662.png)]

  1. 第二种方法在添加英雄时，根据排名将英雄添加到指定位置（如果已经存在该英雄，则添加失败并给出提示），思路如下：

  • 需要根据编号的顺序添加：

    假设新的英雄（节点）为 heroNode

    首先需要找到新添加的节点的位置，通过辅助变量temp遍历找到

    遍历链表判断节点位置的条件：temp.next.no > heroNode.next，条件成立时 temp 节点就是新的节点的上一个节点

    找到结点位置后 添加：
    java heroNode.next = temp.next temp.next = heroNode
    (C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220410155011735.png)]

  1. 修改英雄（节点）的功能

    思路：

    ​ 先通过遍历，找到该节点

    ​ 找到之后：

    temp.name = heroNode.name;
temp.nickname = heroNode.nickname;

  1. 删除英雄（节点）

    思路：

    ​ 先找到需要删除的节点的上一个节点 temp

    ​ 删除节点：
    java temp.next = temp.next.next;

    ​ 被删除的节点，不会有其他的引用指向，会被垃圾回收机制回收

  2. 完整代码演示：

    public class SingleLinkedListDemo {

    public static void main(String[] args) {

        //小试一把
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");

        //创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        //第一种添加英雄的方式，不考虑排序
//        singleLinkedList.add(heroNode1);
//        singleLinkedList.add(heroNode3);
//        singleLinkedList.add(heroNode4);
//        singleLinkedList.add(heroNode2);

        //第二种添加英雄的方式，按编号添加英雄
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.addByOrder(heroNode4);
        singleLinkedList.addByOrder(heroNode2);

        //添加相同编号的英雄，查看是否提示
        singleLinkedList.addByOrder(heroNode2);

        //显示单链表
        singleLinkedList.list();

        //测试修改节点方法
        HeroNode newheroNode4 = new HeroNode(4, "小冲冲", "豹子头林冲");
        singleLinkedList.update(newheroNode4);
        System.out.println("展示修改后的链表：");
        singleLinkedList.list();

        //测试删除英雄（节点）
        singleLinkedList.delete(2);
        System.out.println("展示删除英雄后的链表：");
        singleLinkedList.list();
    }
}

/**
 * 定义SingleLinkedList 管理英雄
 */
class SingleLinkedList{

    /**
     * 先初始化一个头结点，头节点不动，不存放具体的数据
     */
    HeroNode head = new HeroNode(0,"","");

    /**
     * 第一种添加英雄的方式；不考虑顺序
     * 添加节点到单向链表：
     * 添加节点（英雄）的位置为链表的尾节点
     * 思路：当不考虑编号顺序时
     *     1.找到当前链表的最后节点
     *     2.将最后这个节点的next 指向要添加的新的节点
     */
    public void add(HeroNode heroNode){

        //由于头节点不能动，需要一个指针temp辅助遍历
        HeroNode temp = head;
        //遍历链表，直到找到最后
        while (true){
            //如果节点指向的下一个为空，那么这就是链表最后
            if (temp.next == null){
                break;
            }
            //如果没有找到链表的尾节点，就继续向后找，temp后移
            temp = temp.next;
        }
        //此处循环已经完成，temp为尾节点
        //将尾节点的next指向要添加的新节点，则添加节点成功
        temp.next = heroNode;
    }

    /**
     * 第二种添加英雄的方式：
     *      根据排名将英雄插入到指定位置（如果有这个排名则添加失败，并给出提示）
     */
    public void addByOrder(HeroNode heroNode){
        //由于头节点不能动，需要一个指针temp辅助遍历
        HeroNode temp = head;
        //标志是否存在相同排名的英雄，默认为false
        boolean loop = false;
        while (true){
            //判断temp是否在链表的最后
            if (temp.next == null){
                break;
            }
            //找到英雄该插入的位置，应该插入到temp的后面
            if (temp.next.no > heroNode.no){
                break;
            //找到与该英雄相同编号的英雄，loop设置为true
            }else if (temp.next.no == heroNode.no){
                loop = true;
                break;
            }
            //temp后移，循环遍历
            temp = temp.next;
        }
        //loop为true，说明编号存在
        if (loop){
            System.out.printf("存在相同排名的英雄，编号为%d\n",temp.next.no);
            return;
        }else {
            //找到位置
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 显示链表（遍历显示）
     */
    public void list(){
        //先判断链表是否尾空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }

        //头节点不能动，通过一个辅助变量遍历
        HeroNode temp = head.next;
        while (true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //输出节点
            System.out.println(temp);
            //将节点后移
            temp = temp.next;
        }
    }

    /**
     * 根据编号修改英雄（节点）信息，编号不变
     */
    public void update(HeroNode heroNode){
        //由于头节点不能动，需要一个指针temp辅助遍历
        HeroNode temp = head.next;
        //表示是否找到该节点
        boolean flag = true;
        //循环遍历查找节点
        while (true){
            //判断是否找到最后
            if (temp == null){
                break;
            }else {
                if (temp.no == heroNode.no){
                    //找到节点
                    flag = true;
                    break;
                }
            }
            //未找到，节点后移
            temp = temp.next;
        }
        //根据flag判断是否找到节点
        if (flag){
            //找到节点
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;
        }else {
            //没有找到节点
            System.out.println("未找到该节点");
        }
    }

    /**
     * 根据编号删除英雄（节点）的方法
     */
    public void delete(int no){
        //由于头节点不能动，需要一个指针temp辅助遍历
        HeroNode temp = head;
        //表示是否找到该节点
        boolean flag = true;
        //循环遍历查找节点
        while (true){
            //判断是否找到最后
            if (temp == null){
                break;
            }else {
                if (temp.next.no == no){
                    //找到节点
                    flag = true;
                    break;
                }
            }
            //未找到，节点后移
            temp = temp.next;
        }
        //根据flag判断是否找到节点
        if (flag){
            //找到节点
            temp.next = temp.next.next;
        }else {
            //没有找到节点
            System.out.println("未找到该英雄（节点）");
        }
    }

}

/**
 * 定义HeroNode，每个HeroNode对象就是一个节点
 **/
class HeroNode{

    /**
     * 英雄编号
     */
    public int no;
    /**
     * 英雄姓名
     */
    public String name;
    /**
     * 英雄绰号
     */
    public String nickname;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }


}

    展示结果：
    在这里插入图片描述

kisshotlirs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表 --list
Logan的博客
07-09 240
list 单链表
ArrayList和LinkedList中的单链表，双向链表模拟实现其方法功能；
qq_53699052的博客
09-11 353
Hello大家好，今天带来的是对于顺序表、单链表、双向链表的模拟实现，主要对于其常用的API方法进行实现。话不多说，接下来就进入正题吧！ArrayList的模拟实现接下来简单分享一下每个方法实现思路首先构建数组（用来存放元素），构建一个空的int类型的数据（用来确定数据）创建两个构造方法，一个带参数，一个不带参数。对于该链表实现扩容机制。扩容机制详情参考下面代码，或者上面的博客。实现重写toString方法，实现对于下标越界的判断。
单链表创建的LinkList L与LinkList *L区分的问题
weixin_44774262的博客
03-04 4092
在学习线性表的存储结构中，很多人在学习线性表的链式存储结构即单链表时，有人会注意函数传参LinkList L与LinkList *L的问题，如下 下面展示一些 内联代码片。 #include<stdio.h> #include<stdlib.h> typedef int Status; typedef struct Node { ElemType data; //数据域 struct Node* Next; //指针域(指向节点的指针） }Node; typede
java list随机打乱顺序
热门推荐
java_huan的博客
07-23 4万+
通过 Collections.shuffle(list)来打乱顺序 List&lt;String&gt; list = new ArrayList&lt;String&gt;();         list.add("mjb");         list.add("hh");         list.add("lw");         list.add("pqj");         li
linked-list:C用于单链表和双链表
05-12
linked-list C for single linked list and double linked list single_list 结点结构体 创建结点 创建链表 显示链表的数据 获取链表长度 插入结点 删除结点 查找链表中指定的数据 修改链表中指定位置结点的值 修改...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
使用C++实现链表数据结构之单链表.zip
最新发布
03-13
总的来说，理解和实现链表数据结构是学习数据结构和算法的基础，而C++提供了强大的工具来实现这些抽象概念。单链表是链表的一个简单但实用的形式，它能帮助你理解更复杂链表结构，如双向链表和循环链表。通过实践...
Java链表（Linked List）基本原理与实现方法入门示例
08-19
Java链表（Linked List）基本原理与实现方法入门示例 Java链表（Linked List）是一种基础而且重要的数据结构，在Java程序设计中广泛应用。本文将对Java链表（Linked List）的基本原理与实现方法进行详细介绍，并...
数据结构——单链表实验
06-15
1.实验目的 熟悉单链表的定义，单链表的建立方法及相关基本...2、对已建立的单链表实现插入、删除等基本操作； 3、输出链表所有结点数据 4、编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并计算表长。
用单链表实现直接插入排序。
Hhytyq的博客
08-24 2261
代码： #include<stdio.h> #include<stdlib.h> typedef struct Lnode{ int data; struct Lnode*next; }*LinkList,Lnode; LinkList create(LinkList L,int A[],int n){ LinkList p,C; L=(LinkList)mallo...
算法与数据结构-单向链表的直接插入排序和快速排序
shuaixio的博客
08-13 5279
单向链表，直接插入排序，快速排序
单链表--直接插入排序--C++
qq_45911550的博客
12-05 887
#include<iostream> using namespace std; struct Node { int data; Node *next; }; class LinkList { public: LinkList(int a[], int n);//头插法构造一个带头结点的单链表 int Sort_Insert();// 插入排序函数 void Show(); private: int k;// 链表中元素的个数 Node *first, *s, *p, *m, *r,
单链表的基本操作
qq_58529257的博客
10-24 5480
二、实验内容： 1．建立单链表。 2．在单链表上实现插入、删除和查找等操作。 三、实验要求： 编写实现单链表的基本算法（初始化、查找、插入、删除等）的函数，并在此基础上设计一个主程序完成如下功能： 初始化单链表H,类型自选; ⑵分别采用头插法和尾插法建立单链表H，如（a,b,c,d,c）； ⑶输出单链表H的长度； ⑷输出单链表H的第i个元素，如输出单链表H的第3个元素； ⑸输出给定元素的位置，如输出元素a的位置； ⑹在第i个元素前插入给定元素，如在第4个...
自定义LinkedList类（单链表）
Juily家的小蜜果
08-28 2626
自定义链表LinkedList，实现LinkedList的部分方法，理解LinkedList的方法原理。 一，定义节点类 package LinkedList; public class Node { private Object data;//定义数据域 private Node next;//注意这里的next的类型是Node //构造函数1，空节点 ...
数据结构系列学习（三） - 单链表(Linked_List)
曾铎的博客
11-02 1009
在之前我们系统的学习了数据结构中基础的概念、时间复杂度，并且用代码实现了顺序表（Contiguous_List），在对顺序表的学习和实现的文章总结中，我们提到了顺序表的优势在于可以直接访问顺序表中任意一个元素，但是劣势在于如果再头部或者中间位置进行插入或者删除操作，移动元素所产生时空开销较大。
数据结构-单链表(list)
09-11 295
一、概述 队列是数据结构中最常用的一种算法，核心是FFO(First In First Out)，即先进先出，顶部出队列，底部入队列。 二、操作 三、代码 头文件 #ifndef _LIST_H_ #define _LIST_H_ #include <stdio.h> #include <stdlib.h> #define SUCCESS 0 #define FAIL -1 //链表的数据结构 typedef struct ListNode *pListNode
单链表LinkList的实现
独行Freedom的博客
03-21 1419
上两篇文章分析了顺序表的实现方法，顺序存储结构线性表的最大问题是： 插入和删除需要移动大量的元素！那么怎样解决这个问题呢？这就是接下来要讲的线性表的链式存储结构，也就是我们熟知的链表。 同一系列的还有下面的文章： （1）静态单链表StaticLinkList的实现 （2）循环链表 CircleList的实现并解决约瑟夫环问题 （3）双向链表DualLinkList的实现 像顺序表一...
新手对于链表定义*linklist的理解障碍
sinat_36090552的博客
07-24 3728
@[TOC]新手对于链表定义时*linklist的理解障碍 欢迎使用Markdown编辑器 刚开始接触数据结构。学到链表时有定义 typedef struct Node { DataType data;//数据域 struct Node *next;//指针域 }Node，*linklist; 一直不理解，指针*星号到底放在哪的具体规则。 typedef int *int_type; 怎么使用时，int_type j;就等于int *j;了呢？ 我觉得typedef 应该这样用才对啊： t
数据结构教学课件：第3讲 线性表的链式存储结构-1.pdf
06-16
“数据结构教学课件：第3讲 线性表的链式存储结构-1.pdf，涉及计算机科学中的数据结构，特别是线性表的链式表示和实现。” 线性表是一种基本的数据结构，它包含了一组有序的数据元素。在计算机科学中，线性表的链式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值