Java语言实现单链表和双链表

已于 2023-03-16 23:00:43 修改
阅读量247 收藏
点赞数
分类专栏： Java 文章标签： 链表 数据结构 java 算法
于 2023-03-16 17:46:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013471607/article/details/129593575
版权
本文介绍了如何使用Java实现单向链表、双向链表和循环双链表。首先，定义了Node类，包含数据元素和指针。接着，详细阐述了单向链表的添加、删除和查找元素的实现。然后，扩展到双向链表，增加了指向前一个节点的指针，并实现了相应的操作。最后，通过修改双向链表，构建了循环双链表，确保链表的循环性。文章强调了在不同链表结构中维护节点指针的重要性。
摘要由CSDN通过智能技术生成

目录

Node类的定义

单向链表的实现

测试单向链表

双向链表的实现

循环双链表的实现

总结

先来讲一下单向链表，单向链表是一种常用的数据结构，它由一个个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。在Java中，可以通过定义一个Node类来实现单向链表。

Node类的定义

首先，我们需要定义一个Node类，它包含一个数据元素和一个指向下一个节点的指针。代码如下：

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        next = null;
    }
}

单向链表的实现

接下来，我们可以定义一个LinkedList类，它包含一个指向链表头部的指针和一些操作方法，如添加元素、删除元素、查找元素等。具体实现如下：

class LinkedList {
    Node head;

    // 添加元素
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    // 删除元素
    public void remove(int data) {
        if (head == null) {
            return;
        }
        if (head.data == data) {
            head = head.next;
            return;
        }
        Node current = head;
        while (current.next != null) {
            if (current.next.data == data) {
                current.next = current.next.next;
                return;
            }
            current = current.next;
        }
    }

    // 查找元素
    public boolean contains(int data) {
        Node current = head;
        while (current != null) {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    // 输出链表
    public void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
    }
}

测试单向链表

最后，我们可以在main方法中测试单向链表的各个操作方法：

public static void main(String[] args) {
    LinkedList list = new LinkedList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.printList(); // 输出：1 2 3
    list.remove(2);
    list.printList(); // 输出：1 3
    System.out.println(list.contains(1)); // 输出：true
    System.out.println(list.contains(2)); // 输出：false
}

双向链表的实现

要将单向链表修改为双向链表，需要在Node类中添加一个指向前一个节点的指针。具体代码如下：

class Node {
    int data;
    Node next;
    Node prev; // 新增

    public Node(int data) {
        this.data = data;
        next = null;
        prev = null; // 新增
    }
}

 然后，在LinkedList类中也需要对一些操作方法进行修改，以保证每个节点都有一个指向前一个节点的指针。具体代码如下：

class LinkedList {
    Node head;
    Node tail; // 新增

    // 添加元素
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode; // 新增
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
    }

    // 删除元素
    public void remove(int data) {
        if (head == null) {
            return;
        }
        if (head.data == data) {
            head = head.next;
            head.prev = null; // 新增
            return;
        }
        Node current = head;
        while (current.next != null) {
            if (current.next.data == data) {
                current.next = current.next.next;
                if (current.next != null) { // 新增
                    current.next.prev = current;
                } else {
                    tail = current; // 新增
                }
                return;
            }
            current = current.next;
        }
    }

    // 查找元素
    public boolean contains(int data) {
        Node current = head;
        while (current != null) {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    // 输出链表
    public void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
    }
}

需要注意的是，在双向链表中，添加和删除元素时都需要修改前一个节点和后一个节点的指针，以保证链表的完整性。同时，我们还新增了一个指向链表尾部的指针tail，以方便双向链表的操作。

循环双链表的实现

要将双向链表修改为循环双向链表，需要在Node类中让prev指针指向尾节点，具体代码如下：

class Node {
    int data;
    Node next;
    Node prev;

    public Node(int data) {
        this.data = data;
        next = null;
        prev = null;
    }
}

然后，在LinkedList类中对一些操作方法进行修改，使其符合循环双向链表的要求。具体代码如下： 

class LinkedList {
    Node head;
    Node tail;

    // 添加元素
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
            head.prev = tail;
            tail.next = head;
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
            tail.next = head;
            head.prev = tail;
        }
    }

    // 删除元素
    public void remove(int data) {
        if (head == null) {
            return;
        }
        if (head.data == data) {
            head = head.next;
            head.prev = tail;
            tail.next = head;
            return;
        }
        Node current = head;
        while (current.next != head) {
            if (current.next.data == data) {
                current.next = current.next.next;
                current.next.prev = current;
                return;
            }
            current = current.next;
        }
    }

    // 查找元素
    public boolean contains(int data) {
        Node current = head;
        while (current != tail) {
            if (current.data == data) {
                return true;
            }
            current = current.next;
        }
        if (current.data == data) {
            return true;
        }
        return false;
    }

    // 输出链表
    public void printList() {
        Node current = head;
        while (current != tail) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.print(tail.data + " ");
    }
}

需要注意的是，在循环双向链表中，添加和删除元素时都需要修改前一个节点和后一个节点的指针以及头尾节点的指针，以保证链表的完整性和循环性。同时，我们还需要将查找元素的范围扩大到tail节点。

总结

以上就是Java语言实现单向链表、双向链表和循环双链表的方法，这些都是非常常用的数据结构，在实际开发中也经常用到。如果读者对单向链表的实现还有疑问，可以随时向我提问。另外，如果您对其他Java相关的问题也需要帮助，我也会尽力为您解答。

谢谢！

链表的基本概念以及java实现单链表-循环链表-双向链表
mcrwayfun，欢迎你
07-19 1870
前言 线性结构是非常简单且常用的数据结构，而线性表则是一种非常典型的线性结构。 线性表定义 线性表的数据结构 链表 单链表 单链表的定义 单链表的插入和删除 单链表的遍历，清空，判空，获取指定结点 循环链表 循环链表的定义 循环链表的插入和删除 循环链表的遍历，清空 双向链表 双向链表的定义 双向链表的插入和删除 本节代码传送门，欢迎star：https://github...
JAVA单向/双向链表的实现
weixin_33763244的博客
11-15 105
一、JAVA单向链表的操作（增加节点、查找节点、删除节点） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 ...
java中单链表和双向链表的实现
持续学习
09-17 441
java中单链表和双向链表的实现,以及增删改
Java实现单向双向链表原理分析
guyuelin123的博客
09-24 627
本文摘抄至 benjaminwhx 何为链表 摘要 : 链式结构是一种使用对象引用变量来创建对象间的链的数据结构。对象引用变量可以用于创建链式结构，对象引用变量所存储的特定地址一般无关紧要。换句话说，重要的是能够使用引用变量来访问对象，而对象在内存中的特定存储位置并不重要。因此，我们一般将引用变量描述为一个指向对象的名称，而不是显示器地址…
单项和双向链表代码和解析（java)
最新发布
weixin_74457859的博客
02-25 99
代码是双向链表
java两个单链表_java – 附加两个单链表
weixin_39606638的博客
02-27 94
我正在尝试使用Java实现LinkedList,只是为了测试我的技能.我遇到了一个问题,我必须附加两个我创建的链表.我在这里进入一个无限循环.有什么办法可以改进代码并实现所需的输出吗？I / P：列表A：4-> 3-> 2-> 1-> 0列表B：4-> 3-> 2-> 1-> 0O / P应为：4-> 3-> 2-> 1-> ...
数组、单链表和双链表介绍以及双向链表的CC++Java实现 数组和链表.pdf
04-18
C语言的实现需要手动实现双链表的操作，而C++和Java语言则提供了STL和Collection集合来实现双链表。 在C语言中，双链表的实现需要定义双链表的结构体，包括头节点和结点结构体。然后，需要实现双链表的基本操作，...
Java实现单链表与双向链表详解及代码示例
本篇文章主要介绍了如何使用Java编程语言实现单链表和双向链表的数据结构。单链表是一种线性数据结构，每个节点包含一个数据元素和一个指向下一个节点的引用，而双向链表则在单链表的基础上增加了指向前一个节点的...
Java实现单链表以及单链表的操作.zip
09-02
本教程将深入探讨如何使用Java语言来实现单链表及其相关操作。 首先，我们来理解单链表的基本概念。单链表由一系列节点组成，每个节点包含两部分：数据域（用于存储数据）和指针域（指向下一个节点）。链表的最后一...
单链表双向链表java实现
03-27
在这个话题中，我们将深入探讨两种基本的线性数据结构——单链表和双向链表，并通过Java语言来实现它们。 单链表是一种线性数据结构，其中每个元素（称为节点）包含两个部分：数据域和指针域。数据域存储实际的数据...
java创建双向链表,Java双向链表创建/输出---基础<Base>：
weixin_35986494的博客
03-15 68
Java代码：package com.linked;class B{public int data; //数据public B before=null; //前驱public B after=null; //后继public B(){}public B(int data,B before,B after){this.data=data;this.before=before;...
java实现输入一个链表，反转链表后，输出链表的所有元素。
pomay的博客
05-10 2835
public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } public class Solution { public ListNode ReverseList(ListNode head) { if (head =
Java实现反向输出链表
m0_37920544的博客
04-20 3138
面试问题5：从尾到头打印链表        题目：输入一个链表的头结点，从尾到头反过来打印出每个结点的值。        题目解析：一般从尾到头打印链表结点的值的话，可以想到将链表结点的指针反转过来，改变链表方向，这样相当于从头到尾输出了，但是这样就改变了链表的结构。打印通常只是一个只读操作，并不希望改变链表的数据结构，显然这样的方法是不可行的。 (1)解决这个问题肯定要遍历链表的，遍历的顺序是...
java单链表的创建及输出
sd116460的博客
07-28 9371
class Node{     private Object data;     private Node next;     public Node(Object data) {         this.data = data;     }     public Object getData() {         return data;     }     public void setD...
单向链表的逆序输出（java）
热门推荐
alpgao的博客
01-16 1万+
将单向链表逆序输出，方法有三种： a.遍历链表，将每个节点的内容存入一个数组中，然后逆序输出数组(最简单的做法) b.使用栈来逆序输出 c.直接将链表逆序然后输出 先介绍c方法： 1). 若链表为空或只有一个元素，则直接返回； 2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继； ...
Java实现单链表的插入、删除、计算链表的长度和输出链表
xh13007612005的博客
08-14 9787
首先定义单链表（以下统称为链表）：链表有两部分：数据和指向下一个节点的指针。这里引用书中的一张图片：一般是知道头指针，然后根据头指针做插入、删除、反转、排序、输出等操作。使用Java实现链表的结构如下：/** * 链表的结构 * @author haoge */ public class Node { //链表节点的数据 int data; //链表指向的下一个节点的指
Java链表之输出(重点)
wyy
04-16 3081
/*方法名称及作用 !!!!2 public 数据类型 toArray() 将链表以对象数组的形式返回 需要增加一个返回的数组属性内容。 private String [] retArray; */ class Link{ private class Node{ private String data; private Node next; public Node
java单链表输出_java 链表的输出问题
weixin_30582757的博客
02-24 679
我自己写了一个链表，但是当我加入的节点相同是，可以加入，但是在输出是时候，是一个死循环。希望各位大哥大姐，给点建议，我真的是想好久了。但还是没想出解决的办法来。下面是我的...我自己写了一个链表，但是当我加入的节点相同是，可以加入，但是在输出是时候，是一个死循环。希望各位大哥大姐，给点建议，我真的是想好久了。但还是没想出解决的办法来。下面是我的代码。//节点类-------------------...
Java实现链表(包括添加节点/打印输出/反转链表)
weixin_43586713的博客
11-14 1173
首先,自定义首先一个ListNodeDemo类,在里面私有化一个ListNode类,这个类代表的是链表的节点。 public class LinkListDemo { //节点类 private class ListNode{ private Object data; private ListNode next= null; ListNode(){ data = null; } Lis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Richard Du

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值