数据结构 - 单链表

已于 2022-10-31 21:01:35 修改
阅读量2.8k 收藏 6
点赞数 2
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2022-04-29 00:46:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/124481919
版权

文章目录

链表(Linked List) 介绍

链表是有序的列表，但是它在内存中是存储如下
在这里插入图片描述

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

单链表(带头结点)逻辑结构示意图如下

最后一个节点的 next 域 为 空。
在这里插入图片描述

单链表创建和遍历的分析与实现

单链表创建（添加示意图）
在这里插入图片描述

一、添加（创建）

1、先创建一个head 头节点， 作用就是表示单链表的头，不存放具体数据
2、添加：找到当前链表的最后一个节点也就是 next域 为 null，将最后这个节点的next 指向 新的节点

二、遍历

1、通过一个辅助变量（每个节点的 next域赋给这个辅助变量）打印，帮助遍历整个链表，为null 终止

单链表代码实现

/**
 * @ClassName SingleLinkedListDemo
 * @author: shouanzh
 * @Description 单链表
 * @date 2022/4/28 21:38
 */
public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        
        // 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        // 节点加入链表
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);

        // 遍历链表
        singleLinkedList.list();

    }

}

// 定义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;
    }

    // 为了显示方便，我们重新toString
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
    
}


// 定义 SingleLinkedList 单链表
class SingleLinkedList{
    // 先初始化一个头节点,头节点不能动,不存放具体的数据
    private HeroNode head = new HeroNode(0, null, null);

	// 获取头节点
    public HeroNode getHead() {
        return head;
    }

    // 添加节点到单向链表
    // 思路，当不考虑编号顺序时
    // 1. 找到当前链表的最后节点
    // 2. 将最后这个节点的next 指向 新的节点
    public void add(HeroNode heroNode) {
        // 因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点 也就是 next域为 null
        while(true) {
            // next域为 null
            if(temp.next == null) {
                break;
            }
            // 如果next域为 不为null 则继续找下一个节点
            temp = temp.next;
        }
        
        // 当退出while循环时，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) {
                return;
            }
            // 输出节点信息
            System.out.println(temp);
            // 将节点后移
            temp = temp.next;
        }
    }
}

存在的问题
1、无法按照序号排序，只能按照插入顺序排序。
2、插入的序号可以重复。

HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=4, name=林冲, nickname=豹子头]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]

Process finished with exit code 0

单链表：按顺序插入、删除、修改、判重

按顺序插入思路
在这里插入图片描述
1、首先找到新添加的节点的位置, 通过辅助变量temp确定（temp是位于添加位置的前一个节点），通过遍历搞定。
2、新的节点 newNode：newNode.next = temp.next
3、将temp.next = newNode ，新的节点

修改的思路

遍历链表、找到no、然后修改。只能修改 姓名和昵称。

删除节点的思路

在这里插入图片描述
1、我们先找到 需要删除的这个节点的前一个节点 temp
2、temp.next = temp.next.next
3、被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收

以上增、改、删的代码实现

/**
 * @ClassName SingleLinkedListDemo
 * @author: shouanzh
 * @Description 单链表
 * @date 2022/4/28 22:38
 */
public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        
        // 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        // 节点加入链表,按编号顺序（且编号不可重复）
        System.out.println("#######原始数据##########");
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero3); // 测试重复添加

        // 遍历链表
        singleLinkedList.list();

        // 测试删除
        System.out.println("#######测试删除##########");
        singleLinkedList.delete(4);
        singleLinkedList.list();

    }

}

// 定义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;
    }

    // 为了显示方便，我们重新toString
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
    
}


// 定义 SingleLinkedList 单链表
class SingleLinkedList{
    // 先初始化一个头节点,头节点不能动,不存放具体的数据
    private HeroNode head = new HeroNode(0, null, null);

	// 获取头节点
    public HeroNode getHead() {
        return head;
    }

    // 添加节点到单向链表
    // 思路，当不考虑编号顺序时
    // 1. 找到当前链表的最后节点
    // 2. 将最后这个节点的next 指向 新的节点
    public void add(HeroNode heroNode) {
        // 因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点 也就是 next域为 null
        while(true) {
            // next域为 null
            if(temp.next == null) {
                break;
            }
            // 若没有找到最后，则后移
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后一个节点
        // 将最后这个节点的next 指向 新的节点
        temp.next = heroNode;               
    }


    // 按编号顺序添加（如果编号存在，则添加失败，并给出提示）
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        // 因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;// flag标志添加的编号是否存在，默认为false

        while(true) {
            // 最后一个节点
            if(temp.next == null){
                break;
            }

            // temp 的下一个节点的 no 大于新加节点的 no
            // 因为 它满足了 按顺序 ，所以可以插入
            if(temp.next.no > heroNode.no){
                break;
            }

            // 编号以存在(不可重复)
            if(temp.next.no == heroNode.no) {
                flag = true;
                break;
            }

            // 没满足以上，后移下一次节点继续找
            temp = temp.next;
        }

        // 对 flag 进行判断
        if(flag) {
            // 不能添加，说明编号已经存在
            System.out.printf("编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 更新节点的信息, 根据no编号来修改，即no编号不能改
    public void update(HeroNode heroNode) {
        // 判空
        if(head.next == null) {
            System.out.println("链表为空~~");
            return;
        }

        // 根据 no 找到需要修改的节点
        // 定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;// 表示是否找到节点

        while (true) {
            // 链表已经遍历完
            if (temp == null) {
                break;
            }

            // 节点已经找到
            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.printf("没有找到编号为【%d】,无法修改",heroNode.no);
        }
    }

    // 删除
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明：我们在比较时，是temp.next.no 和  需要删除的节点的no比较
    public void delete(int no) {

        HeroNode temp = head;
        boolean flag = false;// 标志是否找到待删除节点

        while(true) {
            // 已经到链表的最后一个节点
            if(temp.next ==null){
                break;
            }

            // 已经找到
            if(temp.next.no == no) {
                flag = true;
                break;
            }

            // 移动继续找
            temp = temp.next;
        }

        // 通过 flag 进行判断
        if(flag) {
            // 已经找到，指向后一个引用
            temp.next = temp.next.next;
        }else {
            System.out.printf("删除的数据不存在【%d】",no);
        }

    }


    // 遍历链表
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空~~~");
            return;
        }
        // 因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;

        while (true) {
            // 判断是否到链表的最后一个节点
            if (temp == null) {
                return;
            }
            // 输出节点信息
            System.out.println(temp);
            // 将节点后移
            temp = temp.next;
        }
    }
}

测试

#######原始数据##########
编号 3 已经存在了, 不能加入
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]
#######测试删除##########
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]

Process finished with exit code 0

获取单链表中有效节点的个数

遍历即可

/**
 * 获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
 * @param head 头节点
 * @return 返回有效节点长度
 */
public static int getLength(HeroNode head) {
    // 空链表
    if (head.next == null) {
        return 0;
    }

    int lenght = 0;
    // 定义一个辅助变量,这里没有统计头节点
    HeroNode cur = head.next;
    while (cur != null) {
        lenght++;
        cur = cur.next; // 遍历
    }
    return lenght;
}

查找单链表中的倒数第k个结点

在这里插入图片描述
有效节点个数 - 倒数第几个节点 = 遍历多少个节点

比如7个节点 获取倒数第三个节点
那么 7-3 = 4，第四个节点.next 就是我们要的结果。

/**
 * 思路：
 * 1、先遍历得到 有效数据个数（总长度不包括头节点）
 * 2、index 倒数第几个节点
 * 3、我们从链表的第一个开始遍历(size-index)个，就可以得到
 * 4、找到则返回当前节点，找不到返回 null
 * @param head 头节点
 * @param index 倒数第几个节点
 * @return HeroNode
 */
public static HeroNode findLastIndexNode(HeroNode head, int index) {
    
    // 判空
    if (head.next == null) {
        return null;
    }

    // 第一个遍历得到链表的长度(节点个数)
    int size = getLength(head);

    // 先做一个index的校验
    if (index <= 0 || index > size) {
        // 查找的位置不能大过总长
        return null;
    }

	// 第二次遍历 size-index 位置，就是我们倒数的第K个节点
    // 定义给辅助变量， for 循环定位到倒数的index
    HeroNode cur = head.next;// 7-3=4, 7个有效节点 获取倒数第三个 遍历4次就可以了
    for (int i = 0; i < size - index; i++) {
        cur = cur.next;
    }
    return cur;
}

单链表的反转

在这里插入图片描述
思路
1、先定义一个节点 reverseHead = new HeroNode()
2、从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端，并记录当前节点的下一个节点。
3、原来的链表的head.next = reverseHead.next
在这里插入图片描述

/**
 * 单链表的反转
 * @param head 头节点
 */
public static void reversalList(HeroNode head) {
    // 若链表为空，或者只有一个则不需要反转
    if (head.next == null || head.next.next == null) {
        return;
    }

    // 定义一个辅助变量，用于遍历原始未反转的那个链表
    HeroNode cur = head.next;
    // 用于动态指向 当前节点【cur】的 下一个节点
    HeroNode next;

    // 新链表(反转后的)的链表头
    HeroNode reverseHead = new HeroNode(0, "", "");

    // 思路： 遍历原始链表，每遍历一个节点将其取出，并放在新链表头(reverseHead)的最前端
    while (cur != null) {
        // 暂时先保存当前节点的下一个节点，用于后移
        next = cur.next;
        // 将遍历出来的新节点.next 指向reverseHead的.next (也就是拼接reverseHead的旧数据)
        cur.next = reverseHead.next;
        // 将 cur 连接到 reverseHead 表头最前端
        reverseHead.next = cur;
        // cur 后移
        cur = next;
    }

    // 将head.next 指向 reverseHead.next , 实现单链表的反转
    head.next = reverseHead.next;
}

从尾到头打印单链表

方式1： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议。

方式2：可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果。

在这里插入图片描述

/**
 * 从尾到头打印单链表 使用栈 先进后出 的特点
 * @param head 头节点
 */
public static void reversalPrint(HeroNode head) {
    
    // 判空
    if(head.next == null){
        return;
    }

    // 创建一个栈，将各个节点压入栈
    Stack<HeroNode> stack = new Stack();
    // 定义辅助变量，用于遍历原始链表
    HeroNode cur = head.next;
    
    // 将链表所有节点入栈
    while (cur != null) {
        stack.push(cur);// 节点入栈
        cur = cur.next;// 节点后移
    }
    // 所有节点依次出栈
    while(stack.size() > 0) {
        // stack的特点是先进后出
        System.out.println(stack.pop());
    }
}

🥳

Zhang_960110
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的插入操作（全）
Boyt1317的博客
05-04 2万+
单链表的插入（全） 三种方式进行插入操作
单链表插入节点的操作
weixin_42576410的博客
12-30 1702
单链表插入节点的操作包括以下几种情况: 在链表头插入节点: 先创建新节点 将新节点的 next 指针指向原来的头结点 将头结点的指针指向新节点 在链表中间插入节点: 先找到要插入节点的前一个节点 创建新节点 将新节点的 next 指针指向前一个节点的 next 指针指向的节点 将前一个节点的 next 指针指向新节点 在链表尾插入节点: 先找到链表的最后一个节点 创建新节点 ...
数据结构之 单链表（详细易懂）
2301_81073406的博客
05-01 728
主要讲了链表的基础---单链表的实现，详细简单易懂
单 链 表 基 础
qq_42481940的博客
06-24 224
标题 2.3 线性表的链式存储 2.3.1 链式存储的原理：使用链式存储方式存储的线性表称为链表 首节点:第一个有效节点 尾节点:最后一个有效节点 头节点:头结点的数据类型和首节点的类型一样，没有存放有效数据， 最最前面的，是在首节点之前的，主要是为了方便对链表的操作。 头指针: (指向头) 指向头节点的指针变量 尾指针:指向尾节点的指针 以线性表中第一个数据元素a1,的存储地址作为线性表的地址，称作线性表的头指针。 有时为了操作方便，在第一个结点之前虚加一个“头结点”，以指向
链表的创建以及链表节点的添加和删除
adr5970的博客
07-29 306
单链表的创建过程有下面几步： 1 ) 定义链表的数据结构; 2 ) 创建一个空表; 3 ) 利用malloc ( )函数向系统申请分配一个节点; 4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新节点接到表尾; 5 ) 推断一下是否有兴许节点要接入链表，若有转到3 )，否则结束; 单链表的输出过程有下面几步 1) 找到表头...
C语言在单链表中插入一个结点
热门推荐
weixin_43484734的博客
11-07 1万+
C语言在单链表中插入一个结点 以前面建立的动态链表为例，编写一个函数，能够在链表中指定位置插入一个结点。 假定链表已按升序排列，将要插入的结点依次与链表中的各结点比较，寻找要插入的位置。结点可以插在表头，表中或表尾。 结点在插入过程中存在以下几种情况： （1）如果原表是空表，只需使链表的头指针head指向被插结点即可。 （2）如果如果被插结点值最小，则应插入第一个结点之前，这种情况下使头指针hea...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
数据结构-单链表的操作
最新发布
06-28
数据结构-单链表的操作
数据结构-单链表的学习及代码实现
09-03
【数据结构-单链表的学习及代码实现】 单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中并不一定是连续存储的，而是通过指针...
C语言-数据结构-单链表完整程序
10-22
本项目提供的“C语言-数据结构-单链表完整程序”应该包含了上述所有功能的实现，通过学习和实践这个项目，你可以深入理解单链表的工作原理，提升C语言编程能力，并巩固数据结构基础。在实际使用中，可以结合具体的...
数据结构-单链表以及对单链表进行的操作
01-08
数据结构-单链表以及对单链表进行的操作
C语言 在链表的指定位置插入节点
10-16
用C语言编写的链表中插入节点的程序，供学习参考交流用
【数据结构-单链表】
weixin_36348982的博客
05-25 1602
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、什么是单链表？二、单链表有哪些特性？二、头结点1.什么是头结点？1.头结点有哪些特性？三、头指针1.什么是头指针？四、单链表的操作1.定义结点结构2.创建链表3.创建结点4.头插法(将新的结点插入到链表中)5.尾插法(将新的结点插入到链表中)6.任意位置插入结点7.删除指定数据的结点8.删除指定位置的结点9.求长度10.修改指定位置结点的数据11.遍历五、代码六、参考总结 前言 为什么需要单链表？ 因为顺序表在插入和删除.
【数据结构】超详细--单向链表
joes_ju的博客
11-14 777
保姆级，超详细的C语言来实现数据结构的单向非循环链表功能
单链表实现两种添加节点
qq_52135683的博客
11-23 288
数据结构，java，链表，添加节点
单链表节点的插入
weixin_30247781的博客
05-08 154
单链表节点的插入 在单链表中某位置（pos个节点）后面插入节点 1.插入到链表首部 2.插入到链表中间 3.插入到蓝标尾部 单链表某个位置插入节点，返回链头指针，pos从0开始计算，0表示插入到head节点后面 node *insert_node(node *head,int pos,int data)...
向单链表中插入、删除节点
菜鸟
05-18 1292
#include #include typedef struct linknode { int data; linknode *next; } Node,*Linklist;//Linklist表示结构体指针 Linklist CreateList_end(int n);//尾插法建立链表 void ShowList(Linklist L);//输出链表内容 void Add
单链表1(创建单链表与添加节点)
m0_49797779的博客
12-06 972
单链表 什么是单链表? 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(val)+ 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 头指针head和终端结点: 单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。链表由头指针唯一确定，单链表可以用头指针的名字来命名。 终端结点无后继，故终端结点的指针域为空，即NULL。 单链
单向链表之有序插入节点（C语言实现）
peng_fp的博客
03-20 1万+
链表的创建查看 按特定值插入链表，要求链表本身使用某种排序方法排好序的。   链表的插入分四种情况： 1、原链表为空时：使头结点head指向新插入的节点p_new;   2、在第一个节点前加入：使头结点head指向新插入的节点p_new，新插入的节点p_new的next指向第一个节点； 3、在中间插入节点：使新加入的节点的前一个节点指向新加入的节点p_new，新加入的节点的next指...
-3 数据结构-单链表-TODO：ReverseLinkList 原地逆转单链表, gCC ）
05-12
下面是使用C语言实现的单链表原地逆转的代码： ```c #include #include struct Node { int data; struct Node* next; }; void reverseList(struct Node** head) { struct Node* prev = NULL; struct Node* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值