数据结构入门(2)----单向链表

已于 2023-04-21 11:30:42 修改
阅读量101 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-04-21 11:30:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36017232/article/details/130284150
版权
本文介绍了带头单链表的概念，包括其在内存中的存储方式、逻辑结构以及结构示例。详细展示了Java代码实现，包括节点类、链表类（包含增、删、改、查等操作函数）以及测试类，并提供了操作实例和运行结果。
摘要由CSDN通过智能技术生成

目录

 

1.带头单链表内存中的存储

2.带头单链表逻辑结构

3.结构示例

4.代码示例

4.1 节点类

4.2 链表类 包含增删改查等操作函数

4.3 测试类

1.带头单链表内存中的存储

1、链表是以节点的方式来存储,是链式存储
2、每个节点包含 data 域， next 域：指向下一个节点.
3、如图：发现链表的各个节点不一定是连续存储.
4、链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

2.带头单链表逻辑结构

       

        逻辑上看就是，根据头连续，但是内存中的排布则未必连续存储 。

3.结构示例

public class SingleLinkedNode {
    private int num;  //编号
    private String name;  //姓名
    private int age;  //年龄

    private SingleLinkedNode next;  //指向下一个元素

    ...
}

4.代码示例

4.1 节点类

public class SingleLinkedNode {
    private int num;  //编号
    private String name;  //姓名
    private int age;  //年龄

    private SingleLinkedNode next;  //指向下一个元素

    public SingleLinkedNode(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public SingleLinkedNode getNext() {
        return next;
    }

    public void setNext(SingleLinkedNode next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "SingleLinkedList{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

4.2 链表类 包含增删改查等操作函数

class SingleLinkedList{
    //设置一个头节点
    private SingleLinkedNode head = new SingleLinkedNode(0,null,0);

    public SingleLinkedNode getHead() {
        return head;
    }


    /**
     * 根据编号查询,编号是唯一的，不允许重复
     * @param num
     * @return
     */
    public SingleLinkedNode queryByNum(int num){
        //使用temp来作为遍历操作的指针
        SingleLinkedNode temp = head;
        //判空
        if (temp.getNext() == null){
            System.out.println("this link is null");
            return null;
        }
        while (true){
            if (temp.getNext() == null){
                System.out.println("can not find this node");
                return null;
            }
            if (temp.getNext().getNum() == num){
                System.out.println("success find this num");
                return temp.getNext();
            }
            temp = temp.getNext();
        }

    }

    /**
     * 根据姓名查询，返回数组
     * @param name
     * @return
     */
    public ArrayList<SingleLinkedNode> queryByName(String name){
        //姓名有可能重复，所以返回一个数组
        ArrayList<SingleLinkedNode> singleLinkedNodeArrayList = new ArrayList<>();
        //计数
        int count = 0;
        //使用temp来作为遍历操作的指针
        SingleLinkedNode temp = head;
        //判空
        if (temp.getNext() == null){
            System.out.println("this link is null");
            return null;
        }
        while (true){
            if (temp.getNext() == null){
                System.out.println("查找结束");
                break;
            }
            if (temp.getNext().getName() == name){
                count++;
                System.out.println("找到了,这是第" + count + "个节点");
                singleLinkedNodeArrayList.add(temp.getNext());
            }
            temp = temp.getNext();
        }
        return singleLinkedNodeArrayList;
    }

    /**
     * 尾插法添加元素
     * @return
     */
    public void add(SingleLinkedNode singleLinkedNode){
        //因为head不能动，所以设置一个temp，用来遍历
        SingleLinkedNode temp = head;
        while (true){
            if (temp.getNext() != null){
                temp = temp.getNext();
            }else {
                temp.setNext(singleLinkedNode);
                break;
            }
        }
    }

    /**
     * 升序插入 头插法
     * @param singleLinkedNode
     */
    public void addByOrder(SingleLinkedNode singleLinkedNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        // 因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        SingleLinkedNode temp = head;
        boolean flag = false;// flag标志添加的编号是否存在，默认为false
        while(true) {
            if(temp.getNext() == null) break;
            if(temp.getNext().getNum() > singleLinkedNode.getNum())
                // 位置找到，就在 temp后面
                // 因为 它满足了 按顺序 ，所以可以插入
                break;
            if(temp.getNext().getNum() == singleLinkedNode.getNum()) {
                // 已经存在改排行的编号(不可重复)
                flag = true;
                break;
            }
            // 没满足以上，后移下一次节点继续找
            temp = temp.getNext();
        }

        // 对 flag 进行判断
        if(flag)
            // 不能添加，说明编号已经存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", singleLinkedNode.getNum());
        else {
            // 插入到链表中，temp的后面
            singleLinkedNode.setNext(temp.getNext());// 我后面的是6号，现在你后面是6号
            temp.setNext(singleLinkedNode);// 我后面是你
        }
    }

    /**
     * 根据编号删除
     * @return
     */
    public boolean deleteByNum(int num){
        SingleLinkedNode temp =head;
        boolean flag = false;
        while (true){
            if (temp.getNext() == null){
               System.out.println("没有这个元素");
               break;
            }
            if (temp.getNext().getNum() == num){
                //判断是否是末尾
                if (temp.getNext().getNext() == null){
                    temp.setNext(null);
                }else {
                    temp.setNext(temp.getNext().getNext());
                }
                System.out.println("元素找到了，已经删除");
                flag = true;
                break;
            }
            temp = temp.getNext();

        }
        return flag;
    }

    /**
     * 根据姓名删除，删除所有姓名为name的节点
     * @param name
     * @return
     */
    public boolean deleteByName(String name){
        SingleLinkedNode temp = head;
        boolean flag = true;
        int count = 0;
        //判空
        if (null == temp.getNext()){
            System.out.println("该链表为空");
            return false;
        }
        while (true){
            //遍历删除后，判断有没有删除
            if (temp.getNext() == null){
                if (count == 0){
                    System.out.println("链表中没有找到");
                    flag = false;
                }else {
                    System.out.println("遍历完成，已经删除所有符合条件的节点");
                }
                break;
            }
            if (name.equals(temp.getNext().getName())){
                count ++;
                //判断是否是最后一个节点
                if (null == temp.getNext().getNext()){
                    System.out.println("已经删除节点" + temp.getNext().getNum());
                    temp.setNext(null);
                    break;
                }else {
                    System.out.println("已经删除节点" + temp.getNext().getNum());
                    temp.setNext(temp.getNext().getNext());
                }
            }
            temp = temp.getNext();
        }
        System.out.println("此时已经删除的节点数为：" + count);
        return flag;
    }

    /**
     * 遍历链表
     */
    public void list(){
        //因为head不能动，所以设置一个temp，用来遍历
        SingleLinkedNode temp = head;
        while (true){
            if (temp.getNext() != null){
                System.out.println(temp.getNext());
            }else {
                break;
            }
            temp = temp.getNext();
        }
    }




}

4.3 测试类

import java.util.ArrayList;

public class SingleLinkedList_Test {
    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //添加
        singleLinkedList.add(new SingleLinkedNode(1,"曹操",20));
        singleLinkedList.add(new SingleLinkedNode(2,"吕布",20));
        singleLinkedList.add(new SingleLinkedNode(3,"孙策",20));
        singleLinkedList.add(new SingleLinkedNode(4,"赵云",20));

        singleLinkedList.addByOrder(new SingleLinkedNode(8,"张飞",20));
        singleLinkedList.addByOrder(new SingleLinkedNode(5,"貂蝉",20));
        singleLinkedList.addByOrder(new SingleLinkedNode(7,"刘备",20));
        singleLinkedList.addByOrder(new SingleLinkedNode(6,"马超",20));
        singleLinkedList.addByOrder(new SingleLinkedNode(9,"马超",20));

        //显示
        singleLinkedList.list();

        //queryByNum
        SingleLinkedNode singleLinkedNode = singleLinkedList.queryByNum(8);
        System.out.println(singleLinkedNode);
        for (int i = 1; i <= 9; i++){
            SingleLinkedNode singleLinkedNode1 = singleLinkedList.queryByNum(i);
            System.out.println(singleLinkedNode1);
        }

        //queryByName
        ArrayList<SingleLinkedNode> singleLinkedNodeArrayList = singleLinkedList.queryByName("马超");
        singleLinkedNodeArrayList.stream().forEach(System.out::println);

        //deleteByNum
//        System.out.println("##########################");
//        System.out.println("执行删除操作");
//        boolean b = singleLinkedList.deleteByNum(1);
//        singleLinkedList.list();

        //deleteByName
        System.out.println("##########################");
        System.out.println("执行删除操作");
        boolean b = singleLinkedList.deleteByName("马超");
        singleLinkedList.list();

    }
}

4.4 结果显示

"C:\Program Files\Java8\Java8_144\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2021.3.2\lib\idea_rt.jar=54496:C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2021.3.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java8\Java8_144\jre\lib\charsets.jar;C:\Program Files\Java8\Java8_144\jre\lib\deploy.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\cldrdata.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\dnsns.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\jaccess.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\jfxrt.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\localedata.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\nashorn.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\sunec.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java8\Java8_144\jre\lib\ext\zipfs.jar;C:\Program Files\Java8\Java8_144\jre\lib\javaws.jar;C:\Program Files\Java8\Java8_144\jre\lib\jce.jar;C:\Program Files\Java8\Java8_144\jre\lib\jfr.jar;C:\Program Files\Java8\Java8_144\jre\lib\jfxswt.jar;C:\Program Files\Java8\Java8_144\jre\lib\jsse.jar;C:\Program Files\Java8\Java8_144\jre\lib\management-agent.jar;C:\Program Files\Java8\Java8_144\jre\lib\plugin.jar;C:\Program Files\Java8\Java8_144\jre\lib\resources.jar;C:\Program Files\Java8\Java8_144\jre\lib\rt.jar;D:\JavaTest\DS_Test\out\production\DS_Test" com.djh.SingleLinkedList.SingleLinkedList_Test
SingleLinkedList{num=1, name='曹操', age=20}
SingleLinkedList{num=2, name='吕布', age=20}
SingleLinkedList{num=3, name='孙策', age=20}
SingleLinkedList{num=4, name='赵云', age=20}
SingleLinkedList{num=5, name='貂蝉', age=20}
SingleLinkedList{num=6, name='马超', age=20}
SingleLinkedList{num=7, name='刘备', age=20}
SingleLinkedList{num=8, name='张飞', age=20}
SingleLinkedList{num=9, name='马超', age=20}
success find this num
SingleLinkedList{num=8, name='张飞', age=20}
success find this num
SingleLinkedList{num=1, name='曹操', age=20}
success find this num
SingleLinkedList{num=2, name='吕布', age=20}
success find this num
SingleLinkedList{num=3, name='孙策', age=20}
success find this num
SingleLinkedList{num=4, name='赵云', age=20}
success find this num
SingleLinkedList{num=5, name='貂蝉', age=20}
success find this num
SingleLinkedList{num=6, name='马超', age=20}
success find this num
SingleLinkedList{num=7, name='刘备', age=20}
success find this num
SingleLinkedList{num=8, name='张飞', age=20}
success find this num
SingleLinkedList{num=9, name='马超', age=20}
找到了,这是第1个节点
找到了,这是第2个节点
查找结束
SingleLinkedList{num=6, name='马超', age=20}
SingleLinkedList{num=9, name='马超', age=20}
##########################
执行删除操作
已经删除节点6
已经删除节点9
此时已经删除的节点数为：2
SingleLinkedList{num=1, name='曹操', age=20}
SingleLinkedList{num=2, name='吕布', age=20}
SingleLinkedList{num=3, name='孙策', age=20}
SingleLinkedList{num=4, name='赵云', age=20}
SingleLinkedList{num=5, name='貂蝉', age=20}
SingleLinkedList{num=7, name='刘备', age=20}
SingleLinkedList{num=8, name='张飞', age=20}

Process finished with exit code 0

djhwork
关注
专栏目录
Python基础算法篇-单向链表
m0_58343270的博客
03-25 913
Python基础算法篇-单向链表
c语言求单向链表中的最大值,C语言基础 - 实现单向链表
weixin_35526110的博客
05-21 1583
回归C基础实现一个单向链表，并有逆序功能 (大学数据结构经常是这么入门的)//定义单链表结构体typedef struct Node{int value;struct Node *next;}Node;//创建链表Node* createNode(int value,Node *next){Node *node = malloc(sizeof(Node));node->value = val...
&4单项链表(链式存储)测试
qq_46418241的博客
02-21 342
对&3代码进行测试 ` //自定义数据类型 typedef struct PERSON { //创建链表 char name[50]; int age; int score; }Person; void MyPrint(void *data) { Person *p=(Person *)data; printf("Name:%s;Age:%d,Score:%d\n",p->name,p->age,p->score); } void test01() { //创建列表
单向、双向链表
大树
12-08 3022
链表 一、介绍 1、介绍 ​ 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域 （1）单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针 （2）双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链
经典单链表测试题（力扣206.）
qq_59293418的博客
05-16 181
203.反转单链表 思路：反转两个节点-->>设置两个指针 prev=NULL；cur=head; 当我们将cur->next=prev时，我们没办法将cur和prev向后移动，所以设置一个临时变量，为了让cur可以往后移动 next=NULL; next=cur->next; cur->next=prev; 接下来就可以移动了。 ...
单链表的方法和测试
weixin_47331155的博客
03-05 406
单链表的测试 /** * 单链表的使用： * 单链表由节点组成 * @author wgsstart * @creat 2021-03-04 16:24 */ public class Test { public static void main(String[] args) { MyLinkedList myLinkedList = new MyLinkedList(); myLinkedList.addLast(10); myLinked
数据结构—单向链表（详解）
热门推荐
梅山
03-16 1万+
基于C语言的链表基础，包括概念，链表的初始化，插入，删除，查找等操作。
课程大作业基于easyx的使用单向链表的数据结构C++源码(带详细注释+exe可执行文件).zip
06-06
课程大作业基于easyx的使用单向链表的数据结构C++源码(带详细注释+exe可执行文件).zip课程大作业基于easyx的使用单向链表的数据结构C++源码(带详细注释+exe可执行文件).zip课程大作业基于easyx的使用单向链表的数据...
单向链表 代码架构
12-29
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针或引用连接在一起，形成一个逻辑上的线性序列。单向链表的每个节点包含两部分...
python单向链表的基本操作细节（小白入门）
12-21
【Python 单向链表的基本操作细节】 链表是一种数据结构，它不同于数组，它将数据元素分散在内存的不同位置，而不是连续存储。单向链表是链表的一种形式，其中每个节点包含一个数据元素和一个指向下一个节点的引用...
链表相关(一）
weixin_48433164的博客
01-07 721
大师傅敢死队风格
单向链表功能编写及测试
sd116460的博客
07-07 583
#pragma once#include&lt;stdio.h&gt;#include&lt;Windows.h&gt;#include&lt;assert.h&gt;#include&lt;stdlib.h&gt; typedef int DataType;typedef struct SListNode{DataType data;struct SListNode *pNext;}SListN...
单链表的简单实现和测试（Java）
weixin_43817702的博客
12-04 590
1.初始化节点 package linklist; public class GoodsNode { public int id; public String name; public double price; public GoodsNode next; public GoodsNode(int id, String name, double price) { this.id = id; this.name = name;
数据结构——单链表模板类
razorEdge的博客
09-24 934
数据结构相关笔记整理（一） 这里主要是整理自己在学习数据结构的时候的笔记，这篇博客主要整理单链表的模板类附带几个内置函数的测试，新手上路，多多包涵，发现错误及时交流..... 第一部分是主类代码：(直接贴了哈~~) #include #include #include "linearList.h" using namespace std; //定义单链表的模板类 t
C语言实现链表之单向链表（十五）测试用例
君临天下的博客
11-08 1914
C语言实现链表之单向链表（十五）测试用例     上一篇文章给出了最后的两个函数，即链表打印和排序，这篇文章将给出所有函数的测试用例，即ListTestTop.c文件。 /* ***************************************************************************************** *
Java 创建并实现单链表类以及实验测试
a215012954的博客
01-12 2055
要求:请完成单链表的创建、查找、插入，并做相应的测试。建议采用接口的方式完成单链表的创建以及单链表所具有的创建、遍历、插入、删除等操作。测试实验的节点类型为简单学生类。简单学生类的属性包括学号、姓名、专业等基本信息以及类的常用操作（得到和修改属性），简单的显示。、 package list; class Student{ public int id;//学号 public Str...
通用型函数——冒泡排序
2401_84654619的博客
10-29 405
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构和算法-动态规划(3)-经典问题
qq_36115196的博客
10-30 829
动态规划(Dynamic Programming): 计算并存储小问题的解， 并将这些解组合成大问题的解。
java-数据结构
最新发布
2301_80708315的博客
10-30 995
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
C语言入门：掌握链表分类与数据结构学习
在C语言学习和数据结构入门中，理解链表的分类对于深入掌握数据结构有着重要的意义。 一、链表的分类 链表通常根据其特点和用途被分为不同的类别，主要包括以下几种： 1. 单向链表（Singly Linked List） 单向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值