数据结构——单链表

棠微风

已于 2024-04-24 23:30:04 修改

阅读量453

点赞数 17

分类专栏：数据结构与算法文章标签：数据结构 java 开发语言

于 2024-04-23 16:50:23 首次发布

本文链接：https://blog.csdn.net/m0_75013084/article/details/138132066

版权

数据结构与算法专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1. 链表介绍

（1）链表是以节点的方式来存储，是链式存储。

（2）每个节点包含data域：存放数据，next域：指向下一个节点。

（3）最后一个节点的next为null，表示链表结束。

（4）链表是有序的列表，但是它在内存中不一定是连续存储。如下图：

（5）链表分为：带头节点的链表和不带头节点的链表，根据实际需求确定。

（6）单链表（带头结点）逻辑结构示意图：

2. 单链表应用实例

使用带有head头的单向链表实现“角色排行榜”，完成对角色排行榜的增删改查操作。

2.1 添加节点到链表尾部

（1）思路分析

1.先创建一个head头节点，表示单链表的头部。

2.之后每添加一个节点，就直接加入到链表的最后。

3.通过一个辅助变量遍历整个链表。

4.示意图：

（2）代码实现

节点类

//定义节点，每个HeroNode对象就是一个节点
class HeroNode {
    public int id; //角色的编号
    public String name; //角色的名字
    public String nickname; //角色的昵称
    public HeroNode next; //指向下一个节点

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

    //重写toString，方便显示信息
    @Override
    public String toString() {
        return "id=" + id + ", name=" + name + ", nickname=" + nickname;
    }
}

链表

//定义链表
class SingleLinkedList {
    //初始化头节点，不存放具体数据，不能改变头节点
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    //添加节点到单向链表尾部，不考虑顺序
    public void add(HeroNode heroNode) {
        HeroNode temp = head; //指针，表示添加位置的前一个节点
        //遍历链表，找到尾节点
        while (true) {
            //找到链表的尾节点
            if (temp.next == null) {
                break;
            }
            //没有找到，就将temp后移
            temp = temp.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; //temp后移
    }
}

2.2 按照顺序添加节点

（1）思路分析

1.先通过遍历，找到新添加节点的前一个位置，通过指针记录位置。

2.让新节点指向下一个节点。

3.让上一个节点指向新节点。

4.示意图：

（2）代码实现

（直接在SingleLinkedList类中添加方法）

//按照顺序，插入节点到指定位置
public void addByOrder(HeroNode heroNode) {
    HeroNode temp = head; //指针，表示添加位置的前一个节点
    boolean flag = false; //表示添加的编号是否存在
    //遍历链表，找添加的位置
    while (true) {
        //判断是否到链表最后
        if (temp.next == null) {
            break;
        }
        //判断位置找到的情况
        if (temp.next.id > heroNode.id) {//找到位置，直接插入
            break;
        } else if (temp.next.id == heroNode.id) {//已经存在
            flag = true;
            break;
        }
        temp = temp.next; //temp后移
    }
    //插入到链表中
    if (flag) {//判断编号是否存在
        System.out.println("当前id" + heroNode + "已经存在！");
    } else {
        heroNode.next = temp.next; //新节点指向下一个节点
        temp.next = heroNode; //当前节点指向新节点
    }
}

2.3 修改节点信息

（1）思路分析

1.先通过遍历，找到指定节点的位置，通过指针记录位置。

2.修改相关信息。

（2）代码实现

（直接在SingleLinkedList类中添加方法）

//修改节点信息，根据id编号查找
public void update(HeroNode newHeroNode) {
    //判断链表是否为空
    if (head.next == null) {
        System.out.println("链表为空！");
        return;
    }
    HeroNode temp = head.next; //指针，指向修改的节点
    boolean flag = false; //表示是否找到该节点
    //遍历链表，找指定节点
    while (true) {
        //判断是否到链表最后
        if (temp == null) {
            break;
        }
        //判断位置找到的情况
        if (temp.id == newHeroNode.id) {//找到指定id
            flag = true;
            break;
        }
        temp = temp.next; //temp后移
    }
    //修改节点信息
    if (flag) { //找到
        temp.name = newHeroNode.name;
        temp.nickname = newHeroNode.nickname;
    } else { //没找到
        System.out.println("没有找到" + newHeroNode.id + "编号");
    }
}

2.3 删除节点

（1）思路分析

1.先通过遍历，找到待删除节点的前一个位置，通过指针记录位置。

2.将这个节点的next直接指向下下个节点

3.被删除的节点不会有任何引用指向，会被垃圾回收机制回收。

4.示意图：

（2）代码实现

（直接在SingleLinkedList类中添加方法）

//删除节点，根据id进行删除
public void del(int id) {
    HeroNode temp = head; //指针，表示删除节点的前一个节点
    boolean flag = false; //表示是否找到待删除的节点
    遍历链表，找指定节点
    while (true) {
        //判断是否到链表最后
        if (temp.next == null) {
            break;
        }
        //找到待删除节点
        if (temp.next.id == id) {
            flag = true;
            break;
        }
        temp = temp.next; //temp后移
    }
    //删除节点
    if (flag) { //找到
        temp.next = temp.next.next; //指向删除节点的后一个节点
    } else {
        System.out.println("要删除的" + id + "号节点不存在");
    }
}

2.4 单链表常见题目

（1）求单链表中有效节点的个数

//获取单链表中节点的个数，不算头节点
//head 头节点
public static int getLength(HeroNode head) {
    //判断链表是否为空
    if (head.next == null) {
        return 0;
    }
    int length = 0;//记录节点个数
    HeroNode pointer = head.next; //指针，指向第一个节点
    //遍历链表
    while (pointer != null) {
        length++;
        pointer = pointer.next;
    }
    return length;
}

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

//查找倒数第k个节点
//head 头节点，k 倒数第几个节点
public static void findLastIndex(HeroNode head, int k) {
    //判断链表是否为空
    if (head.next == null) {
        System.out.println("链表为空");
        return;
    }
    int length = 0;//记录节点个数
    HeroNode pointer = head.next; //指针，指向第一个节点
    while (pointer != null) {//遍历链表
        length++;
        pointer = pointer.next;
    }
    if (k <= 0 || k > length) {//校验
        System.out.println("找不到");
        return;
    }
    int sum = length - k; //表示整数第几个节点
    pointer = head.next; //重置指针
    while (sum > 0) {//遍历链表，找指定节点
        sum--;
        pointer = pointer.next;
    }
    System.out.println("倒数第"+ k + "个节点为" + pointer);
}

（3）单链表的反转

思路分析：

1.先定义一个新链表的头节点。

2.从头遍历原链表，每遍历一个节点，就放在新链表的第一个位置。

3.让原链表的头结点指向新链表头节点。

//单链表的反转
public static void reverseList(HeroNode head) {
    //判断链表是否为空，或只有一个节点
    if (head.next == null || head.next.next == null) {
        return;
    }
    HeroNode pointer = head.next; //指针，指向第一个节点
    HeroNode next = null; //存放指针的下一个节点
    HeroNode reverseHead = new HeroNode(0, "", "");//新的链表
    //遍历原链表，每遍历一个节点，就放在新链表的前面
    while (pointer != null) {
        next = pointer.next;//先暂时保存当前节点的下一个节点
        pointer.next = reverseHead.next;//下一个节点指向新链表的第一个节点
        reverseHead.next = pointer;//新头节点指向当前节点
        pointer = next;//指针后移
    }
    head.next = reverseHead.next; //原头节点指向新头节点
}

（4）逆序打印单链表

思路分析：

1.可以使用上面的反转链表再打印，但这样会破坏原本的链表结构。

2.使用栈（先进后出）的特点进行逆序打印。

3.先遍历链表，将每个节点加入到栈中，然后遍历栈，进行打印。

//逆序打印单链表，使用栈（先进后出）完成
public static void reversePrint(HeroNode head) {
    //判断链表是否为空
    if (head.next == null) {
        System.out.println("链表为空");
        return;
    }
    Stack<HeroNode> stack = new Stack<HeroNode>();//创建栈
    HeroNode pointer = head.next; //指针，指向第一个节点
    //遍历链表，将每个节点加入到栈中
    while (pointer != null) {
        stack.add(pointer); //使用add方法入栈
        pointer = pointer.next; //指针后移
    }
    //遍历栈，打印节点信息
    while (stack.size() > 0)  {
        System.out.println(stack.pop()); //使用pop方法出栈
    }
}

棠微风

关注

17
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
数据结构——单链表

（1）链表是以节点的方式来存储，是链式存储。（2）每个节点包含data域：存放数据，next域：指向下一个节点。（3）最后一个节点的next为null，表示链表结束。（4）链表是有序的列表，但是它在内存中。
复制链接

扫一扫