单链表的java实现（图文解说）

最新推荐文章于 2024-05-05 22:29:45 发布

LySong_

最新推荐文章于 2024-05-05 22:29:45 发布

阅读量3.2k

点赞数 25

分类专栏：数据结构 Java基础文章标签：链表数据结构 java 算法

本文链接：https://blog.csdn.net/weixin_43265151/article/details/104659700

版权

数据结构同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

Java基础

3 篇文章 0 订阅

订阅专栏

1.链表（LinkedList）的介绍

在这里插入图片描述
总结上图：

链表是一个有序的列表
链表不同于数组，链表是以结点的形式存储，在物理空间上不一定连续
链表的每个结点的内部包含data（数据）域，next（指针）域，指针域指向下一个结点的位置
链表的头结点不存储数据，只是为了指向链表的开头

2.数据声明

由上图的分析可知，每个结点应该包括两部分，一部分为数据，一部分为指针，指向下一个区域，所以我们可以这样定义:

//定义Node,每个Node对象就是一个结点
class Node{
    public String data;
    public Node next; //指向下一个结点

    //构造器
    public Node(String data) {
        this.data = data;
    }
    //toString方法
    @Override
    public String toString() {
        return "Node{" +
                "data='" + data + '\'' +
                '}';
    }
}

在这里我们通过一个类来表示一个结点，在类中声明数据及下一个结点next。

3.对链表操作的分析

在这里插入图片描述
那么如何对链表进行操作呢？

3.1单链表初始化

单链表的初始化需要对创建一个头结点

//先初始化一个头结点，头结点不能动，头结点不能变化，方便找到链表的头
    private Node head = new Node("这是头结点");

3.2遍历操作

首先我们应该了解如何遍历整个链表，与数组的遍历不同，因为链表没有下标，我们可以拿到的节点只有头结点，所以每次进行遍历的时候应该从头结点开始向后遍历，但因为头结点的特殊性（不能改变，如果改变，就找不到其他的结点），我们需要一个辅助的变量temp来进行遍历操作。

Node temp = head;
//遍历链表，找到最后
while (temp.next != null){ //如果temp还有下一个结点继续循环
     temp = temp.next; //如果找到了，将结点后移
 }

通过循环的操作，不断对temp赋值赋给temp.next，使temp不断后移，直到an，此时temp.next为空，所以这样就遍历到了链表的尾部。
那么理解了链表的遍历操作我们就可以开始写链表的增删改插入显示的操作了

3.3增加操作

在这里插入图片描述
如上图示，我们需要对链表进行增加操作时，首先需要拿到当前链表的最后一个结点，所以需要对链表进行遍历操作，然后将temp.next = newNode.next
思路:
1.首先将头结点head赋值给temp，用作遍历时的辅助结点
2.然后进行遍历，直到temp.next=null
3.然后将temp.next=newNode.next，即可完成添加操作

//添加结点到单向链表
    /*
    思路：当不考虑顺序时
    1.找到当前链表的最后一个结点
    2.将最后这个结点的next指向新的结点
     */
    public void add(Node Node){
        //因为head结点不能动，因此我们需要一个辅助的遍历temp
        Node temp = head;
        //遍历链表，找到最后
        while (temp.next != null){ //如果temp还有下一个结点继续循环
            temp = temp.next; //如果找到了，将结点后移
        }
        //当退出while循环时，temp就指向了链表的最后
        //temp.next赋值就好
        temp.next = Node;
    }

3.4删除操作

在这里插入图片描述
如上图示，我们需要对结点进行删除的时候，应该让temp指向需要删除的结点的前一个结点，然后将temp.next=temp.next.next,这样需要删除的结点就没有引用指向它，就会被java的垃圾回收机制回收
思路：
1.我们需要先遍历到需要删除的结点，如果遍历时还没有到足够的次数，就出现了temp.next=null，说明需要删除的结点不存在。
在这里插入图片描述
2.当找到后则temp.next=temp.next.next
3.被删除的无引用指向，会被垃圾回收机制删除

3.5插入操作

在这里插入图片描述
结点的插入操作需要将新的结点作为参数传入，首先需要遍历到需要插入的结点，将temp.next=newNode.next,这样就可以将temp的后面结点的位置赋给newNode.next,然后将temp.next=newNode,这样就可以把新节点放到需要插入的结点后面
1.我们需要先遍历到需要插入的结点，如果遍历时还没有到足够的次数，就出现了temp.next=null，说明需要删除的结点不存在。（原理同3.6）
2.当遍历到需要插入的结点时，newNode=temp.next,temp.next=newNode

	//链表插入
    //找到插入的前一个位置
    //temp.dat = node.next
    public void insert(Node node,int n){
        //因为头结点不能动，因此我们需要一个辅助的遍历temp
        //因为单链表，因此我们找的temp是位于添加位置的前一个结点，否则插入不了
        if(n <= 0){
            System.out.println("数据不合法！");
        }
        Node temp = head;
        boolean flag = false; //标志为是否符合插入条件
        for(int i = 0; i < n; i++){
            if(temp.next == null){
                System.out.println("无法插入结点，插入点不存在");
                break;
            }
            if(i == n - 1 && temp.next != null) {
                flag = true;
            }
            temp = temp.next;
        }
        if(flag == true){
            node.next = temp.next;
            temp.next = node;
        }
    }

3.6修改操作

在这里插入图片描述
修改操作非常简单，遍历至需要修改的结点，将数据进行替换temp.data=Node.data
1.我们需要先遍历到需要修改的结点，如果遍历时还没有到足够的次数，就出现了temp.next=null，说明需要删除的结点不存在。（原理同3.6）
2.进行数据替换，temp.data=Node.data

//修改结点的信息，根据结点位置来修改
    public void update(Node newNode,int n){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此我们需要一个辅助的遍历temp
        Node temp = head;
        //找到需要修改的结点，根据传入的n值
        for(int i = 0 ; i < n ; i++){
            if(temp.next == null){
                System.out.println("该结点不存在");
                break;
            }
            temp = temp.next;
            if(i == n-1){
                temp.data = newNode.data;
            }
        }
    }

3.6打印操作

打印操作很简单，遍历每一个结点并把数据打印出来


    //显示链表（遍历）
    public void list(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此我们需要一个辅助的遍历temp
        Node temp = head.next;
        while (temp != null){
            System.out.println(temp);
            temp = temp.next;
        }
    }

4.源代码（含测试用例）

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //进行一个测试
        //先创建节点
        Node node1 = new Node("这是第一个结点");
        Node node2 = new Node("这是第二个结点");
        Node node3 = new Node("这是第三个结点");
        Node node4 = new Node("这是第四个结点");

        //创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入
        singleLinkedList.add(node1);
        singleLinkedList.add(node2);
        singleLinkedList.add(node3);
        singleLinkedList.add(node4);
        //插入操作
        singleLinkedList.insert(new Node("这是插入的结点，应该在第三个结点之后"),3);
        //显示链表
        singleLinkedList.list();
        singleLinkedList.update(new Node("修改了最后一个结点"),5);
        singleLinkedList.list();
        //链表删除
        singleLinkedList.delete(4);
        singleLinkedList.list();
    }
}

//定义SingleLinkedList
class SingleLinkedList{
    //先初始化一个头结点，头结点不能动，头结点不能变化，方便找到链表的头
    private Node head = new Node("这是头结点");
    //添加结点到单向链表
    /*
    思路：当不考虑顺序时
    1.找到当前链表的最后一个结点
    2.将最后这个结点的next指向新的结点
     */
    public void add(Node Node){
        //因为head结点不能动，因此我们需要一个辅助的遍历temp
        Node temp = head;
        //遍历链表，找到最后
        while (temp.next != null){ //如果temp还有下一个结点继续循环
            temp = temp.next; //如果找到了，将结点后移
        }
        //当退出while循环时，temp就指向了链表的最后
        //temp.next赋值就好
        temp.next = Node;
    }
    //删除结点
    //思路
    //1.先找到需要删除的结点的前一个结点
    //2.temp.next=temp.next.next
    //被删除的无引用，会被垃圾回收机制回收
    public void delete(int n){
        Node temp = head;
        for(int i = 0 ; i < n ; i++){
            if(temp.next == null){
                System.out.println("不存在该结点");
            }
            if(i == n-1){
                temp.next = temp.next.next;
            }
            temp = temp.next;
        }
    }

    //链表插入
    //找到插入的前一个位置
    //temp.dat = node.next
    public void insert(Node node,int n){
        //因为头结点不能动，因此我们需要一个辅助的遍历temp
        //因为单链表，因此我们找的temp是位于添加位置的前一个结点，否则插入不了
        if(n <= 0){
            System.out.println("数据不合法！");
        }
        Node temp = head;
        boolean flag = false; //标志为是否符合插入条件
        for(int i = 0; i < n; i++){
            if(temp.next == null){
                System.out.println("无法插入结点，插入点不存在");
                break;
            }
            if(i == n - 1 && temp.next != null) {
                flag = true;
            }
            temp = temp.next;
        }
        if(flag == true){
            node.next = temp.next;
            temp.next = node;
        }
    }

    //修改结点的信息，根据结点位置来修改
    public void update(Node newNode,int n){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此我们需要一个辅助的遍历temp
        Node temp = head;
        //找到需要修改的结点，根据传入的n值
        for(int i = 0 ; i < n ; i++){
            if(temp.next == null){
                System.out.println("该结点不存在");
                break;
            }
            temp = temp.next;
            if(i == n-1){
                temp.data = newNode.data;
            }
        }
    }

    //显示链表（遍历）
    public void list(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此我们需要一个辅助的遍历temp
        Node temp = head.next;
        while (temp != null){
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

//定义Node,每个Node对象就是一个结点
class Node{
    public String data;
    public Node next; //指向下一个结点

    //构造器
    public Node(String data) {
        this.data = data;
    }
    //toString方法
    @Override
    public String toString() {
        return "Node{" +
                "data='" + data + '\'' +
                '}';
    }
}

运行结果

在这里插入图片描述

欢迎访问我的个人博客

LySong_

关注

25
点赞
踩
93

收藏

觉得还不错? 一键收藏
2
评论
单链表的java实现（图文解说）

1.链表（LinkedList）的介绍总结上图：链表是一个有序的列表链表不同于数组，链表是以结点的形式存储，在物理空间上不一定连续链表的每个结点的内部包含data（数据）域，next（指针）域，指针域指向下一个结点的位置链表的头结点不存储数据，只是为了指向链表的开头2.数据声明由上图的分析可知，每个结点应该包括两部分，一部分为数据，一部分为指针，指向下一个区域，所以我们可以这样...
复制链接

扫一扫