【数据结构】java实现单链表

已于 2023-08-02 11:42:20 修改
阅读量455 收藏 1
点赞数 2
文章标签： 数据结构 链表
于 2023-08-02 11:40:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JZJ_LYH/article/details/132054740
版权

链表是一种常见的数据结构，由一系列节点组成。每个节点包含一个数据元素和一个指向下一个节点的指针。节点通过指针连接在一起，形成一个链式结构。
在这里插入图片描述
链表适合在需要频繁插入和删除节点的场景中使用，因为链表的插入和删除操作只需要修改相邻节点的指针，而不需要移动其他节点。相比之下，数组在插入和删除操作时需要移动其他元素，效率较低。

在Java中要实现链表，可以定义一个节点类，包含一个数据域和一个指针域。然后定义一个链表类，包含一个头节点指针和一些基本操作。

我们首先要定义出一个节点类

/**
 * @Description: 单链表节点类
 */
public class Node<E> {
	// 数据
    E data;
    // 指针
    Node next;

    public Node() {
    }

    public Node(E data) {
        this.data = data;
    }
}

然后定义一个单链表类
【为了方便操作我们设置了首尾节点，当然也可以不用尾节点，遍历一遍链表就找到尾节点了】

/**
 * @Description: 单链表类
 */
public class LinkList<E> {
    //    头结点
    private Node head;
    //    尾节点
    private Node last;
    //    链表的实际长度
    private int size;

    public LinkList() {
        head = new Node();
        last = head;
    }

    public Node getHead() {
        return head;
    }

    //    判空
    public boolean isEmpty() {
        return size == 0;
    }

    //    打印单链表
    public void display(Node head) {
        Node temp = head.next;
        while (temp.next != null) {
            System.out.print(temp.data + "-->");
            temp = temp.next;
        }
        System.out.println(temp.data);
    }
｝

接下来我们就可以用单链表来实现一些基本操作了

  • 创建单链表（头插法、尾插法）
// 传入一个数组作为链表的内容 当然也可以只传入一个data数据，那直接插入就可以，不用for循环了
public void creatLinkList(E[] arr) {
//        头插法
    Node p;
    /*for(E i:arr){
        p = new Node(i);
        p.next = head.next;
        head.next = p;
        size++;
    }*/
//        尾插法
    for (E i : arr) {
        p = new Node(i);
        last.next = p;
        last = p;
        size++;
    }
}
  • 在指定位置插入节点
public void insertElement(int index, E data) throws Exception {
    if (index > size + 1 || index < 0) {
        throw new Exception("请选择合适的位置插入！");
    }
    Node p = new Node(data);
    Node temp = head;
    if (this.isEmpty()) {
        head.next = p;
        size++;
        last = p;
        return;
    } else if (index == size + 1) {
        last.next = p;
        last = p;
        size++;
        return;
    }
    for (int i = 1; i < index && temp.next != null; i++) {
        temp = temp.next;
    }
    p.next = temp.next;
    temp.next = p;
    
    size++;
}
  • 修改指定位置节点
public void changeElement(int index, E data) throws Exception {
    if (index > size || index <= 0) {
        throw new Exception("请选择合适的位置修改！");
    }
    Node temp = head;
    for (int i = 1; i <= index && temp != null; i++) {
        temp = temp.next;
    }
    temp.data = data;
}
  • 删除指定位置节点
public void removeElement(int index) throws Exception {
    if (index > size || index <= 0) {
        throw new Exception("请选择合适的位置删除！");
    }
    Node temp = head;
    for (int i = 1; i < index && temp != null; i++) {
        temp = temp.next;
    }
    if (index == size) {
        temp.next = null;
        last = temp;
    } else {
        temp.next = temp.next.next;
    }
}
  • 根据索引找元素
public Object getElementByIndex(int index) throws Exception {
    if (index > size || index <= 0) {
        throw new Exception("超出范围！");
    }
    Node temp = head;
    for (int i = 1; i <= index && temp != null; i++) {
        temp = temp.next;
    }
    System.out.println(temp.data);
    return temp.data;
}
  • 根据元素找索引
public int getIndexByElement(E data) {
    Node temp = head;
    for (int i = 0; i <= size && temp != null; i++) {
        if (data.equals(temp.data) || data == temp.data) {
            System.out.println(i);
            return i;
        }
        temp = temp.next;
    }
    if (!data.equals(temp.data) || data != temp.data) {
        System.out.println("该链表不存在该元素");
    }
    return -1;
}
  • 删除重复节点
/**
我们可以利用集合不能存放重复元素的特点，往一个集合中添加元素如果添加成功就留着，如果添加失败说明是重复元素
*/
public void deleteIdenticalElement() {
//        判断是否需要删除
    if (size < 2) {
        System.out.println("该链表不用进行删除重复元素操作！");
        return;
    }
    HashSet<E> set = new HashSet<>();
    Node temp = head.next;
    Node h1 = head;
    while (temp != null) {
        if (set.contains(temp.data)) {
            h1.next = temp.next;
            size--;
        } else{
            set.add((E) temp.data);
            h1 = temp;
        }
        temp = temp.next;
    }
}
  • 将单链表置逆
//    将单链表就地置逆
public void ReverseOrder() {
    Node temp = head;
    Node temp1 = temp.next;
    Node n;
    while (temp1 != null) {
        n = temp1;
        temp1 = temp1.next;
        if (temp == head) {
//                把第一个节点断开
            n.next = null;
        } else {
//                用头插法置逆
            n.next = temp;
        }
        temp = n;
    }
    head.next = temp;
}

//    将单链表置逆算法二
public void ReverseOrder2() {
    Node prev = null;
    Node current = head.next;
    while (current != null) {
        Node next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    head.next = prev;
}
  • 在一个递增有序列表中，插入一个值使其依旧保持有序
public void insertKeepOrderly(E data) {
    Node p = new Node(data);
    if (size == 0) {
        head.next = p;
        size++;
        return;
    }
    Node temp = head;
    while (temp.next != null) {
        if ((Integer) temp.next.data < (Integer) data) {
            temp = temp.next;
        } else {
            p.next = temp.next;
            temp.next = p;
            return;
        }
    }
    temp.next = p;
}
  • 合并两个递增有序单链表A,B到有序单链表C
public Node mergeLinkList(LinkList<Integer> list1, LinkList<Integer> list2) {
    Node h1 = list1.getHead().next;
    Node h2 = list2.getHead().next;
    if (h1 == null) {
        return h2;
    }
    if (h2 == null) {
        return h1;
    }
    Node h = new Node();
    Node last = h;
    while (h1 != null && h2 != null) {
        if ((int) h1.data <= (int) h2.data) {
            last.next = h1;
            last = h1;
            h1 = h1.next;
        } else {
            last.next = h2;
            last = h2;
            h2 = h2.next;
        }
    }
    if (h1 != null) {
        last.next = h1;
    }
    if (h2 != null) {
        last.next = h2;
    }
    return h;
}

最后附上完整的代码

/**
 * @Description: 单链表类
 */
public class LinkList<E> {
    //    头结点
    private Node head;
    //    尾节点
    private Node last;
    //    链表的实际长度
    private int size;

    public LinkList() {
        head = new Node();
        last = head;
    }

    public Node getHead() {
        return head;
    }

    public Node getLast() {
        Node temp = head.next;
        while (temp != null) {
            temp = temp.next;
        }
        return temp;
    }

    //    判空
    public boolean isEmpty() {
        return size == 0;
    }


    //    打印单链表
    public void display(Node head) {
        Node temp = head.next;
        while (temp.next != null) {
            System.out.print(temp.data + "-->");
            temp = temp.next;
        }
        System.out.println(temp.data);
    }

    //    头插法,尾插法
    public void creatLinkList(E[] arr) {
        //        头插法
        Node p;
        /*for(E i:arr){
            p = new Node(i);
            p.next = head.next;
            head.next = p;
            size++;
        }*/
        //        尾插法
        for (E i : arr) {
            p = new Node(i);
            last.next = p;
            last = p;
            size++;
        }
    }

    //    指定位置插入元素
    public void insertElement(int index, E data) throws Exception {
        if (index > size + 1 || index <= 0) {
            throw new Exception("超出范围！");
        }
        Node p = new Node(data);
        Node temp = head;
        if (this.isEmpty()) {
            head.next = p;
            size++;
            last = p;
            return;
        } else if (index == size + 1) {
            last.next = p;
            last = p;
            size++;
            return;
        }
        for (int i = 1; i < index && temp.next != null; i++) {
            temp = temp.next;
        }
        p.next = temp.next;
        temp.next = p;
        size++;
    }

    //    修改指定位置元素
    public void changeElement(int index, E data) throws Exception {
        if (index > size || index <= 0) {
            throw new Exception("超出范围！");
        }
        Node temp = head;
        for (int i = 1; i <= index && temp != null; i++) {
            temp = temp.next;
        }
        temp.data = data;
    }

    //    删除指定位置元素
    public void removeElement(int index) throws Exception {
        if (index > size || index <= 0) {
            throw new Exception("超出范围！");
        }
        Node temp = head;
        for (int i = 1; i < index && temp != null; i++) {
            temp = temp.next;
        }
        if (index == size) {
            temp.next = null;
            last = temp;
        } else {
            temp.next = temp.next.next;
        }
    }

    //    查找第i个元素
    public Object getElementByIndex(int index) throws Exception {
        if (index > size || index <= 0) {
            throw new Exception("超出范围！");
        }
        Node temp = head;
        for (int i = 1; i <= index && temp != null; i++) {
            temp = temp.next;
        }
        System.out.println(temp.data);
        return temp.data;
    }

    //    查找元素i的索引
    public int getIndexByElement(E data) {
        Node temp = head;
        for (int i = 0; i <= size && temp != null; i++) {
            if (data.equals(temp.data) || data == temp.data) {
                System.out.println(i);
                return i;
            }
            temp = temp.next;
        }
        if (!data.equals(temp.data) || data != temp.data) {
            System.out.println("该链表不存在该元素");
        }
        return -1;
    }

    //    删除重复元素
    /*public void deleteIdenticalElement() throws Exception {
//        判断是否需要删除
        if (size < 2) {
            System.out.println("该链表不用进行删除重复元素操作！");
            return;
        }
//        第一层遍历用来获取待判断的节点
//        第二层循环用来查找是否有相同元素，有的话直接删除
        Node p1 = head.next;
        Node p2;
        int l = 0;  //用来记录删除了几个元素
        int t;      //用来记录第二层遍历下标
        while (p1 != null) {
            p2 = p1.next;
            t = 2;
            while (p2 != null) {
                if (p2.data.equals(p1.data)) {
                    this.removeElement(t - l);
                    l++;
                }
                t++;
                p2 = p2.next;
            }
            l = 0;
            t++;
            p1 = p1.next;
        }
    }*/

    public void deleteIdenticalElement() {
    //        判断是否需要删除
        if (size < 2) {
            System.out.println("该链表不用进行删除重复元素操作！");
            return;
        }
        HashSet<E> set = new HashSet<>();
        Node temp = head.next;
        Node h1 = head;
        while (temp != null) {
            if (set.contains(temp.data)) {
                h1.next = temp.next;
                size--;
            } else{
                set.add((E) temp.data);
                h1 = temp;
            }
            temp = temp.next;
        }
        temp  = head.next;
        while (temp.next != null) {
            temp = temp.next;
        }
        last = temp;
        System.out.println(last.data);
    }

    //    将单链表就地置逆
    public void ReverseOrder() {
        Node temp = head;
        Node temp1 = temp.next;
        Node n;
        while (temp1 != null) {
            n = temp1;
            temp1 = temp1.next;
            if (temp == head) {
    //                把第一个节点断开
                n.next = null;
            } else {
    //                用头插法置逆
                n.next = temp;
            }
            temp = n;
        }
        head.next = temp;
    }

    //    将单链表置逆算法二
    public void ReverseOrder2() {
        Node prev = null;
        Node current = head.next;
        while (current != null) {
            Node next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        head.next = prev;
    }

    //    在一个递增有序列表中，插入一个值使其依旧保持有序
    public void insertKeepOrderly(E data) {
        Node p = new Node(data);
        if (size == 0) {
            head.next = p;
            size++;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            if ((Integer) temp.next.data < (Integer) data) {
                temp = temp.next;
            } else {
                p.next = temp.next;
                temp.next = p;
                return;
            }
        }
        temp.next = p;
    }

    //    合并两个递增有序单链表A,B到有序单链表C
    public Node mergeLinkList(LinkList<Integer> list1, LinkList<Integer> list2) {
        Node h1 = list1.getHead().next;
        Node h2 = list2.getHead().next;
        if (h1 == null) {
            return h2;
        }
        if (h2 == null) {
            return h1;
        }
        Node h = new Node();
        Node last = h;
        while (h1 != null && h2 != null) {
            if ((int) h1.data <= (int) h2.data) {
                last.next = h1;
                last = h1;
                h1 = h1.next;
            } else {
                last.next = h2;
                last = h2;
                h2 = h2.next;
            }
        }
        if (h1 != null) {
            last.next = h1;
        }
        if (h2 != null) {
            last.next = h2;
        }
        return h;
    }
}
Monkey_Jun
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java创建一个链表
a402498234的博客
03-28 1031
Java创建一个链表
Java单向链表的实现
m0_73050958的博客
07-13 314
引言： 在计算机科学中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。一、单向链表的定义单向链表是 一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。链表的第一个节点称为头节点，最后一个节点称为尾节点，尾节点的指针指向null。二、单向链表的实现在Java 中，可以使用类来实现单向链表。每个节点可以定义为一个类，包含两个属性：数据和指向下一个节点的引用。一个简单的Java单向链表的实现示例：```java。
【数据结构】Java实现单链表
qq_53869058的博客
03-18 1387
由于其底层是一段连续空间，当，效率比较低，因此。因此：java集合中又引入了LinkedList，即链表结构。链表是一种存储结构，数据元素的是通过链表中的次序实现的。实际中链表的结构非常多样，以下情况组合起来就有6种链表结构：（2）虽然有这么多的链表的结构，但是我们重点掌握两种，一般不会单独用来存数据。实际中更多是作为，如哈希桶、图的邻接表等等。在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。
Java实现头插和尾插的单链表
qq_62745502的博客
07-22 345
Java实现头插和尾插的单链表
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1875
单链表增删改查，排序，反转，倒序打印，两条单链表合并
java 数据结构单链表的实现
08-30
"Java 数据结构单链表的实现" Java 数据结构单链表是 Java 语言中的一种基本数据结构，用于存储和操作链表数据。在 Java 中，单链表可以通过定义链表节点和链表操作工具类来实现。 一、链表节点的定义 链表节点是...
java实现数据结构单链表示例(java单链表)
09-04
单链表是一种简单且常用的数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一个节点的引用。在这个实例中，我们将详细讨论如何使用Java实现单链表。 1. **单链表节点类(Node)**： - `Node` 类内部定义...
Java实现单链表以及单链表的操作.zip
09-02
单链表是一种简单但灵活的数据结构，常用于实现各种抽象数据类型，如队列、栈和映射。本教程将深入探讨如何使用Java语言来实现单链表及其相关操作。 首先，我们来理解单链表的基本概念。单链表由一系列节点组成，每...
java实现单链表之逆序
09-03
在Java编程中，单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。单链表逆序是指将链表中的元素顺序颠倒，使得原本的第一个元素变为最后一个，原本的最后一个...
Java实现单链表翻转实例代码
08-31
在Java编程中，单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个值和一个指向下一个节点的引用。单链表的翻转是数据结构与算法中的一个经典问题，通常有两种主要的实现方式：递归和非递归。本篇...
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3221
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
超详细！java实现链表
qq_63255075的博客
03-05 406
小白用的java链表
数组实现单链表 Java详细讲解
qq_41810415的博客
08-04 749
注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。I k x，表示在第 k 个插入的数后面插入一个数 x（此操作中 k 均大于 0）。D k，表示删除第 k 个插入的数后面的数（当 k 为 0 时，表示删除头结点）。现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。在第 k 个插入的数后插入一个数。删除第 k 个插入的数后面的数；...
用java创建一个自己的链表
最新发布
qq_45576281的博客
01-21 471
【代码】用java创建一个自己的链表。
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Java系列技术之数据结构与算法
04-18
<p> <img src="https://img-bss.csdn.net/201904181428307037.png" alt="" /> </p>
JAVA 单链表的实现
LYE_LYE的博客
08-29 369
JAVA单链表的实现
Java实现链表结构
热门推荐
wangkr的专栏
08-19 4万+
Java实现链表结构这里主要记录了一下学习用Java实现链表的方法。假设你有一点Java基础，了解接口、内部类的内容，同时也学过数据结构中链表的内容，对设计模式中的工厂方法和迭代方法知道一些，（因为这里将不介绍这些基础知识，我的水平也讲不清）又想了解在Java中实现链表，那么接着看吧。（最近读严老师应该没记错名字吧，如果错了抱歉>的帖子说应该在博文中说明帖子的读者范围，不要浪费大家的时间，这最近写...
java自定义链表
weixin_44901065的博客
06-26 193
首先实现一个节点类： package jimo.love; public class Node { private String data;//数据 private Node next;//指向下一个节点 public Node(String data){ this.data = data; } public void setNex...
Java实现单链表基础操作与数据结构概念详解
课程的学习材料丰富多样，包括多本经典的教材，如《数据结构、算法与应用:java语言描述》、《数据结构Java语言描述》等，这些书籍深入浅出地介绍了数据结构的基础理论，如数据、数据元素、数据项的概念，以及数据的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值