Java实现单链表及基本功能

最新推荐文章于 2024-01-05 22:58:58 发布
最新推荐文章于 2024-01-05 22:58:58 发布
阅读量910 收藏 18
点赞数 3
分类专栏： 今日说码 文章标签： 链表 算法 数据结构 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36798272/article/details/106456492
版权

一、 前言

  最近开始学习数据结构和算法。之所以说是学习而不是复习，还是因为自己这方面太薄弱了。长时间以来感觉自己都忘得差不多了。希望这次以写博客的方式能够记录自己这段时间的成长，也方便以后自己有遗忘再回到这复习吧，防止再花额外的时间去寻找相关的知识点。
  因为在部分算法题中用到了栈的思想，那么就不得不提链表。数组和链表都是线性存储结构的基础，栈和队列都是线性存储结构的应用。本文这次主要讲解的是单链表的基础知识点。

二、回顾与知新

  在学习链表之前，我们先回顾一下数组。因为有数组作为比较对象后，就会很容易理解链表这种存储结构了。

2.1数组说明
数组是一种连续存储线性结构，元素类型相同，大小相等。

备注：以上这段话中，“大小相等”有点疑惑，猜测的意思是内存中每个元素占用内存大小相等，如果有读者知道还请您在评论区指教。
在这里插入图片描述
数组的优点：

  • 查询速度快

数组的缺点：

  • 插入和删除效率低。
  • 必须先确定数组的大小，可能浪费内存（部分内存未使用）。
  • 内存空间要求高，必须有足够的连续内存空间。
  • 不能动态拓展（数组大小是固定的）。
2.2链表说明

看完了数组，回到我们的链表

链表是离散存储线性结构

在这里插入图片描述
链表的优点：

  • 插入删除元素很快
  • 大小没有固定，拓展很灵活
  • 内存利用率高，不会浪费内存

链表的缺点：

  • 查询速度很慢

链表相关术语介绍，依然通过上面那个图来标注说明：
在这里插入图片描述
确定一个链表我们只需要头指针，通过头指针就可以把整个链表都推导出来

链表又分了好几类：

单向链表：

  特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。其中每个结点都有指针成员变量指向列表中的下一个结点

双向链表：

  它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点

循环链表：

  能通过任何一个结点找到其他所有的结点，将两种(双向/单向)链表的最后一个结点指向第一个结点从而实现循环
操作链表要时刻记住的是：

  • 结点中指针域指向的就是一个结点了！

三、Java实现链表

算法：

  • 遍历
  • 查找
  • 清空
  • 销毁
  • 求长度
  • 排序
  • 删除节点
  • 插入节点

首先，我们定义一个类作为结点，里面包含两个域：

  • 数据域
  • 指针域

Node结点类代码：

/**
 * @program: Day1
 * @description: 单向链表结点
 * @author: sunzhen
 * @create: 2020-05-29 22:57
 **/
public class Node {

    //数据域
    public Integer data;

    //指针域，指向下一个节点
    public Node next;

    public Node() {
    }

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

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

}

然后创建测试类（我将head结点定义在成员变量上）

**
 * @program: Day1
 * @description: 单向链表算法测试
 * @author: sunzhen
 * @create: 2020-05-29 23:07
 **/
public class LinkedListTest {

    //头结点
    private static Node head = new Node();

}
3.1增加节点

向链表中插入数据：

  • 找到尾节点进行插入
  • 即使头节点.next为null，不走while循环，也是将头节点与新节点连接的
/**
 * @Description: 添加数据
 * @Param: [value]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void addData(int value) {
    //初始化要加入的结点
    Node newNode = new Node(value);

    //临时结点
    Node temp = head;

    //找到尾节点
    while (temp.next != null) {
        temp = temp.next;
    }

    //已经包括了头节点.next为null的情况了～
    temp.next = newNode;
}
3.2遍历链表

上面我们已经编写了增加方法，现在遍历一下看一下是否正确。
从首节点开始，不断往后面找，直到后面的节点没有数据：

/**
 * @Description: 遍历链表
 * @Param: [head]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void traverse(Node head) {
    //临时节点，从首节点开始
    Node temp = head.next;

    while (temp != null) {

        if (temp.data != null) {
            System.out.println(temp.data);
        }

        //继续下一个
        temp = temp.next;
    }
}
3.3获取链表的长度

获取链表的长度就很简单了，遍历一下，每得到一个节点+1即可。

/**
 * @Description: 获取链表的长度
 * @Param: [head]
 * @return: int
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static int linkListLength(Node head) {
    /*Node temp = head;
    int length = 0;
    while (temp.next != null) {
        length++;
        temp = temp.next;
    }
    return length;*/

    int length = 0;

    //临时节点，从首节点开始
    Node temp = head.next;

    // 找到尾节点
    while (temp != null) {
        length++;
        temp = temp.next;
    }

    return length;

}
3.4插入节点

插入一个节点到链表中，首先得判断这个位置是否是合法的，才能进行插入。
找到想要插入的位置的上一个节点就可以了。

/**
 * @Description: 插入结点
 * @Param: [head, index, value]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void insertNode(Node head, int index, int value) {
    //首先需要判断指定位置是否合法，
    //插入的合法范围（包含头尾）：1 <-> 链表长度+1
    if (index < 1 || index > linkListLength(head) + 1) {
        System.out.println("插入位置不合法。");
        return;
    }

    //临时节点，从头节点开始
    Node temp = head;

    //记录遍历的当前位置
    int currentPos = 0;

    //初始化要插入的节点
    Node insertNode = new Node(value);

    //这里循环成立的条件是小于等于用户能插入的最后一个位置（链表长度+1）
    while (currentPos <= linkListLength(head)) {

        //找到上一个节点的位置了
        if ((index - 1) == currentPos) {

            //temp表示的是上一个节点

            //将原本由上一个节点的指向交由插入的节点来指向
            insertNode.next = temp.next;

            //将上一个节点的指针域指向要插入的节点
            temp.next = insertNode;

            return;

        }

        currentPos++;
        temp = temp.next;
    }

}
3.5删除节点

删除某个位置上的节点其实是和插入节点很像的， 同样都要找到上一个节点。将上一个节点的指针域改变一下，就可以删除了。

/**
 * @Description: 删除结点
 * @Param: [head, index]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void deleteNode(Node head, int index) {
    //首先需要判断指定位置是否合法，合法范围（包含头尾）： 1 <-> 链表长度
    if (index < 1 || index > linkListLength(head)) {
        System.out.println("删除位置不合法。");
        return;
    }

    //临时节点，从头节点开始
    Node temp = head;

    //记录遍历的当前位置
    int currentPos = 0;
    
    while (temp.next != null) {

        //找到上一个节点的位置了
        if ((index - 1) == currentPos) {

            //temp表示的是上一个节点

            //temp.next表示的是想要删除的节点

            //将想要删除的节点存储一下
            Node deleteNode = temp.next;

            //想要删除节点的下一个节点交由上一个节点来控制
            temp.next = deleteNode.next;


            //Java会回收它，设置不设置为null应该没多大意义了(个人觉得,如果不对请指出哦～)
            deleteNode = null;

            return;

        }
        currentPos++;
        temp = temp.next;
    }
}
3.6对链表进行排序

冒泡排序

**
 * @Description: 对链表进行排序
 * @Param: [head]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void sortLinkList(Node head) {
    Node currentNode;
    Node nextNode;
    for (currentNode = head.next; currentNode.next != null; currentNode = currentNode.next) {
        for (nextNode = head.next; nextNode.next != null; nextNode = nextNode.next) {
            if (nextNode.data > nextNode.next.data) {
                int temp = nextNode.data;
                nextNode.data = nextNode.next.data;
                nextNode.next.data = temp;
            }
        }
    }
}
3.7找到链表中倒数第k个节点

这个算法挺有趣的。设置两个指针p1、p2，让p2比p1快k个节点，同时向后遍历，当p2为空，则p1为倒数第k个节点

/**
 * @Description: 找到链表中倒数第k个结点
 * 找到链表中倒数第k个节点(设置两个指针p1、p2，让p2比p1快k-1个节点，同时向后遍历，当p2为空，则p1为倒数第k个节点
 * @Param: [head, k]
 * @return: com.sunzhen.blog.Node
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static Node findKNode(Node head, int k) {
    if (k < 1 || k > linkListLength(head))
        return null;
    Node p1 = head;
    Node p2 = head;

    // p2比怕p1快k-1个节点
    for (int i = 0; i < k - 1; i++)
        p2 = p2.next;


    // 只要p2为null，那么p1就是倒数第k个节点了
    while (p2.next != null) {
        p2 = p2.next;
        p1 = p1.next;
    }
    return p1;
}
3.8删除链表重复数据
/**
 * @Description: 删除链表重复数据
 * 遍历链表，把遍历的值存储到一个Hashtable中，在遍历过程中，若当前访问的值在Hashtable中已经存在，
 * 则说明这个数据是重复的，因此就可以删除。
 * <p>
 * 优点：时间复杂度较低O(n)
 * 缺点：在遍历过程中需要额外的存储空间来保存已遍历过的值
 * @Param: [head]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void deleteDuplicateV1(Node head) {
    Hashtable<Integer, Integer> table = new Hashtable<Integer, Integer>();
    Node temp = head.next;
    Node pre = null; //辅助链表的头节点
    while (temp != null) {
        if (table.containsKey(temp.data))
            pre.next = temp.next;
        else {
            table.put(temp.data, 1);
            pre = temp;
        }
        temp = temp.next;
    }
}

/**
 * @Description: 删除链表重复数据
 * 对链表进行双重循环遍历，外循环正常遍历链表，假设外循环当前遍历的结点为cur，内循环从cur开始遍历，
 * 若碰到与cur所指向结点值相同，则删除这个重复结点
 * <p>
 * 优点：不需要额外的存储空间
 * 缺点：时间复杂度较高O(n^2)
 * @Param: [head]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void deleteDuplicateV2(Node head) {
    /*Node currentNode;
    Node temp;
    for (currentNode = head.next; currentNode != null; currentNode = currentNode.next) {
        for (temp = currentNode; temp.next != null;) {
            if (temp.next.data == currentNode.data) {
                temp.next = temp.next.next;
            } else {
                temp = temp.next;
            }
        }
    }*/

    Node p = head;
    while (p != null) {
        Node q = p;
        while (q.next != null) {
            if (q.next.data == p.data) {
                q.next = q.next.next;
            } else
                q = q.next;
        }
        p = p.next;
    }
}

/**
 * @Description: 删除链表重复数据
 * 外循环当前遍历的结点为cur，内循环从链表头开始遍历至cur，只要碰到与cur值相同的结点就删除该结点，同时内循环结束，
 * 因为与cur相同的结点只可能存在一个（如果存在多个，在前面的遍历过程中已经被删除了）
 * <p>
 * 优点：采用这种方法在特定的数据发布的情况下会提高算法的时间复杂度
 * @Param: [head]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void deleteDuplicateV3(Node head) {
    Node p = head.next;
    while (p != null) {
        Node q = head.next;
        while (q.next != p && q.next != null) {
            if (q.next.data == p.data) {
                q.next = q.next.next;
            } else
                q = q.next;
        }
        p = p.next;
    }
}
3.9查询链表的中间节点

这个算法也挺有趣的：一个每次走1步，一个每次走两步，走两步的遍历完，然后走一步的指针，那就是中间节点

**
 * @Description: 查询链表的中间节点
 * @Param: [head]
 * @return: com.sunzhen.blog.Node
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static Node searchMid(Node head) {
    Node p1 = head;
    Node p2 = head;
    // 一个走一步，一个走两步，直到为null，走一步的到达的就是中间节点
    while (p2 != null && p2.next != null && p2.next.next != null) {
        p1 = p1.next;
        p2 = p2.next.next;
    }
    return p1;
}
3.10通过递归从尾到头输出单链表
/**
 * @Description: 通过递归从尾到头输出单链表
 * @Param: [head]
 * @return: void
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static void printListReversely(Node head) {
    if (head == null) {
        return;
    }
    printListReversely(head.next);
    if (head.data != null) {
        System.out.println(head.data);
    }
}
3.11反转链表

递归：从尾部开始处理

/**
 * @Description: 反转链表（递归实现）
 * @Param: [head]
 * @return: com.sunzhen.blog.Node
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static Node linkedListReverserV1(Node head) {
    Node prev = null;
    if (head == null || head.next == null) {
        prev = head;
    } else {
        Node tmp = linkedListReverserV1(head.next);
        head.next.next = head; //将前一个放到后一个的后一个实现倒置
        head.next = null; //切断之前顺序的指针
        prev = tmp;
    }
    return prev;
}

在这里插入图片描述
非递归：从头部开始处理

/**
 * @Description: 反转链表（非递归实现）
 * @Param: [head]
 * @return: com.sunzhen.blog.Node1
 * @Author: sunzhen
 * @Date: 2020/5/30
 */
public static Node linkedListReverserV2(Node head) {
    Node prev = null;
    while (head != null) {
        Node tmp = head;
        head = head.next;
        tmp.next = prev; //倒置
        prev = tmp;
    }
    return prev;
}

在这里插入图片描述

四、参考文献

本文大量参考Java3y的博客，感谢您。

五、 补充说明

5.1为什么数组要比链表查询速度快？
5.2为什么链表要比数组插入和删除效率低？
眺望灬前方
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java数据结构篇之链表
MasterJundarj的博客
09-23 2937
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3233
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
Java中的链表
weixin_52758364的博客
12-09 3362
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
Java实现链表
cainiaowangdake的博客
06-06 1285
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1884
单链表增删改查，排序，反转，倒序打印，两条单链表合并
Java单链表基本操作的实现
09-02
本篇文章将深入探讨Java中的单链表及其基本操作的实现。单链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的引用。 在Java中，我们可以创建一个`Node`类来表示链表中的节点。每个...
Java实现单链表的基本操作
01-06
本文将深入探讨如何使用Java语言实现单链表的基本操作，包括创建链表、插入节点、删除节点以及遍历链表等关键功能。 首先，我们需要理解单链表的概念。单链表是一种线性数据结构，其中每个元素（称为节点）包含两个...
Java实现单链表以及单链表的操作.zip
09-02
以上就是使用Java实现单链表及其实现的各种操作的详细解析。掌握这些基本操作，能帮助我们在处理复杂问题时更加得心应手。在实际编程中，根据具体需求，还可以扩展链表的功能，例如支持双向链表、循环链表等。
java单链表的基本操作.zip
最新发布
01-09
除了上述基本操作，还可以实现更多的高级功能，如链表的分割、连接、求链表长度、查找中间节点等。 通过理解和熟练掌握这些基本操作，你可以有效地在Java程序中利用单链表解决各种问题。实践是提高技能的关键，...
java实现单链表
04-04
现在，我们已经了解了如何在Java中实现单链表的基本操作。通过这些基础，你可以进一步扩展这个数据结构，例如实现删除元素、查找元素、反转链表等功能。记住，理解并熟练掌握数据结构对于任何Java程序员来说都是至关...
Java单链表的实现代码
01-04
数据结构中使用Java实现单链表的创建、读取等基本操作
java——单链表的实现
m0_60178502的博客
05-14 3425
目录 单链表的组成： 1.Node类（节点类） 2.SingleLinkedList类 单链表的实现： add del modify check show 单链表的测试： 单链表的组成： java中单链表的实现由两个类组成，分别是： 1.Node类（节点类） public class Node { //data域 public int age; public String name; //next域 public N
Java数据结构---链表的基本用法（如创建等基本使用方法）
gaoqiandr的博客
01-05 882
本文简单地介绍了如何使用Java实现数据结构中的链表
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 941
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
数据结构之单链表（java版）
qq_42489613的博客
10-23 1384
数据结构就是用某种结构去储存数据
Java 单链表知识点总结及代码实现
路先生的杂货铺，学习总结+好文分享
09-27 754
JAVA实现单链表 本文通过JAVA实现单链表的基本功能 实现功能 单链表的： 头部增加、头部删除 尾部增加、尾部删除 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示； 全新的 KaTeX数学公式 语法； 增加了支持甘特图的mermaid语法1 功能； 增加了 多屏幕编辑 Markdown文章功能； 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能...
Java单向链表的实现
m0_73050958的博客
07-13 315
引言： 在计算机科学中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。一、单向链表的定义单向链表是 一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。链表的第一个节点称为头节点，最后一个节点称为尾节点，尾节点的指针指向null。二、单向链表的实现在Java 中，可以使用类来实现单向链表。每个节点可以定义为一个类，包含两个属性：数据和指向下一个节点的引用。一个简单的Java单向链表的实现示例：```java。
超详细！java实现链表
qq_63255075的博客
03-05 409
小白用的java链表
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值