数据结构Java版：链表（基础篇）

已于 2022-03-02 19:42:10 修改
阅读量537 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-03-02 17:22:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ustcluter/article/details/123232938
版权

这里写目录标题

简介

  • 链表

    1、线性表的一种，物理存储结构上非连续，是链式的存储结构。
    2、动态分配内存，链表在内存中是不连续的。
    3、插入和删除的效率高，查找的效率低。
    - 插入或删除不需要移动其他元素
    - 查询通过遍历定位元素，时间复杂度是O(n)

  • 数组

    1、把所有元素按次序依次存储，是顺序的存储结构。
    2、静态分配内存，数组在内存中是连续的。
    3、插入和删除的效率低，查找的效率高。
    - 插入和删除需要移动其他元素，时间复杂度是O(n)
    - 查询利用下标定位，时间复杂度是O(1)

一、定义

  • 链表结构示例

    在这里插入图片描述

  • 链表节点定义

public class ListNode {
		
    public int val;
    public ListNode next;

    public ListNode() {
    }

    public ListNode(int val) {
        this.val = val;
    }

    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

二、增删操作

1. 删除链表节点

删除前
删除后

  • 删除操作：
    1、遍历找到要待删除的节点，或者节点位置。
    2、记录待删除节点 curNode，前置节点 preNode。
    3、执行删除 preNode.next = curNode.next。
    如上图从上到下的过程。删除Node(4)，执行:

     Node(3).next = Node(5)

2. 添加链表节点

  • 添加操作：

    1、遍历找到要待插入节点 node 的位置。
    2、记录待插入位置 curNode，前置节点 preNode。
    3、执行添加 node.next = curNode; preNode.next = node。
    如上图从下到上的过程。新增Node(4)，执行 :

     Node(3).next = Node(4)；
 Node(4).next = Node(5);

3. 增删案例

通过一段代码例子，来体验一下链表的增删操作。自定义一个链表类 LinkedNodeList。

  • 实现：
/*
自定义链表
 */
public class LinkedNodeList {

    private int size;
    private ListNode head;

    public LinkedNodeList() {
        this.size = 0;
        this.head = null;
    }

    /**
     * 添加操作
     */
    public void addToHead(ListNode node) {
        // 处理头节点
        node.next = this.head;
        this.head = node;

        // 处理节点个数
        this.size++;
    }

    public void addToTail(ListNode node) {
        if (head == null) {
            this.addToHead(node);
            return;
        }
        ListNode curNode = head;
        while (curNode.next != null) { // 循环结束后，curNode指向最后一个节点
            curNode = curNode.next;
        }
        curNode.next = node;
        size++;
    }

    /*
    定义: 插入节点到指定下标
    示例: 1->2->3
    操作: insert -> Node(7), 1
    结果: 1->7->2->3
     */
    public void insert(ListNode node, int index) {

        if (index == 0) { // 添加到头部
            this.addToHead(node);
            return;
        }

        if (index == size) { // 添加到尾部
            this.addToTail(node);
            return;
        }

        if (index < -1 || index > size) {
            throw new IllegalArgumentException(String.format("[error: index is out of range.][size: %s][index: %s]", size, index));
        }

        ListNode preNode = head;
        ListNode curNode = head;
        // 从0走到下标index需要走index步，走到index前一个节点需要index-1步
        while (index > 0) { // 循环index curNode移动到index位置
            preNode = curNode;
            curNode = curNode.next;
            index--;
        }
        node.next = curNode;
        preNode.next = node;
        size++;
    }

    /**
     * 删除操作
     */
    public void removeHead() {
        if (size == 0) {
            throw new NullPointerException("当前链表为空，不支持删除操作");
        }
        head = head.next;
        size--;
    }

    public void removeTail() {
        if (size == 0) {
            throw new NullPointerException("当前链表为空，不支持删除操作");
        }
        if (size == 1) {
            removeHead();
            return;
        }
        ListNode preNode = head;
        ListNode curNode = head;
        while (curNode.next != null) {
            preNode = curNode;
            curNode = curNode.next; // 循环结束，curNode是最后一个节点
        }
        preNode.next = null;
        size--;
    }

    public void removeByIndex(int index) {

        if (index == 0) { // 删除链表头节点
            this.removeHead();
            return;
        }
        if (index == size - 1) { // 删除链表尾节点
            this.removeTail();
            return;
        }

        if (index < -1 || index >= size) {
            throw new IllegalArgumentException(String.format("[error: index is out of range.][size: %s][index: %s]", size, index));
        }

        // 从0到下标index需要走index步
        ListNode preNode = head;
        ListNode curNode = head;
        if (index > 0) { // 循环index curNode移动到index位置
            preNode = curNode;
            curNode = curNode.next;
            index--;
        }
        // System.out.println("delete element: " + curNode.val);
        preNode.next = curNode.next;
        size--;
    }

    public ListNode head() {
        return this.head;
    }

    public int size() {
        return this.size;
    }

    public boolean empty() {
        return this.size == 0;
    }

    public void show() {
        ListNode curNode = head;
        while (curNode != null) {
            System.out.print(curNode.val + " ");
            curNode = curNode.next;
        }
        System.out.println();
    }
}
  • 测试入口
public static void main(String[] args) {

       LinkedNodeList list = new LinkedNodeList();

       // add to head
       list.addToHead(new ListNode(1));
       list.addToHead(new ListNode(2));
       list.addToHead(new ListNode(3));
       System.out.print("添加节点到链表头部后结果: ");
       list.show();

       // insert by index
       list.insert(new ListNode(7), 1);
       System.out.print("插入节点 Node(7) 到下标1的位置到链表头部后结果: ");
       list.show();

       // add to tail
       list.addToTail(new ListNode(8));
       list.addToTail(new ListNode(9));
       System.out.print("添加节点到链表尾部后结果: ");
       list.show();

       System.out.println("-----------------------------");

       // delete head
       list.removeHead();
       System.out.print("删除链表头节点后结果: ");
       list.show();

       // delete tail
       list.removeTail();
       System.out.print("删除链表尾节点后结果: ");
       list.show();

       // delete by index
       list.removeByIndex(1);
       System.out.print("删除链表下标为1的节点后结果: ");
       list.show();

       System.out.println("最终链表长度为: " + list.size());
   }

  • 结果预览

     添加节点到链表头部后结果: 3 2 1 
 插入节点 Node(7) 到下标1的位置到链表头部后结果: 3 7 2 1 
 添加节点到链表尾部后结果: 3 7 2 1 8 9 
 -----------------------------
 删除链表头节点后结果: 7 2 1 8 9 
 删除链表尾节点后结果: 7 2 1 8 
 删除链表下标为1的节点后结果: 7 1 8 
 最终链表长度为: 3

三、常用基础操作

  • 示例:
    在这里插入图片描述

1. 寻找链表中间节点(快慢指针)

当节点个数为奇数没什么需要讨论，当为偶数时。会存在两个节点都可以称为中间节点.

	public ListNode getMidListNode(ListNode head) {
        if (head == null) {
            return null;
        }
        // 偏右
        ListNode fast = head;
        // 偏左
        // ListNode fast = head.next;

        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

2. 反转链表(原址改变指向)

	/*
    input: 1->2->3->4->5

    left                    right
    // null                    1->2->3->4->5
    1->null                 2->3->4->5
    2->1->null              3->4->5
    3->2->1->null           4->5
    4->3->2->1->null        5
    5->4->3->2->1->null     null
     */
  
    private static ListNode reverse(ListNode head) {

        if (head == null) {
            return null;
        }

        ListNode left = null;
        ListNode right;
        while (head != null) {
            right = head.next;
            head.next = left;
            left = head;
            head = right;
        }
        return left;
    }

3. 巩固

通过一道题目来加强对链表基础操作的使用。

  • 描述：给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

  • 思路：
    1、将链表分成左右两个部分；
    2、对右半部分做翻转；
    3、比较左右两个链表是否相同（注意奇偶因素）。

  • 实现：

	/*
    1、找出链表的中间节点
    2、对后半段做 链表反转
    3、比较前后半段
    4、恢复链表
     */
    public static boolean isPalindrome(ListNode head) {
        // 结果
        boolean flag = true;

        ListNode midNodeList = findMidNodeList(head);
        // 右半段
        ListNode rightNode = midNodeList.next;
        ListNode reversedRightNode = reverseListNode(rightNode);
        ListNode left = head;
        ListNode right = reversedRightNode;
        while (right != null) {
            if (right.val != left.val) {
                flag = false;
                break;
            }
            right = right.next;
            left = left.next;
        }
        // 还原
        midNodeList.next = reverseListNode(reversedRightNode);
        return flag;
    }

    /*
    寻找链表的中间节点
    1->2->3->4     // 奇数返回2
    1->2->3->4->5  // 偶数返回3
     */
    private static ListNode findMidNodeList(ListNode head) {
        if (head == null) {
            return null;
        }
        // 虚节点，也可以使用上述的方法
        ListNode dummy = new ListNode(0, head);
        ListNode fast = dummy;
        ListNode slow = dummy;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    /*
    链表反转
    1->2->3->4->5->null
    left           right
    null           1->2->3->4->5->null
    1->null        2->3->4->5->null
    2->1->null     3->4->5->null
     */
    private static ListNode reverseListNode(ListNode head) {
        ListNode left = null;
        ListNode right;

        ListNode curNode = head;

        while (curNode != null) {
            right = curNode.next;
            curNode.next = left;
            left = curNode;
            curNode = right;
        }

        return left;
    }
ustcluter
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言基础入门：链表详解篇
C语言C++学习俱乐部：765860056
11-24 2781
链表概述 　　链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分： 一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素;……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”(表示“空地址”)，链表到此结束。 　　链表的各类操.
JAVA链表实现类（数据结构学习）
12-14
JAVA链表实现类（数据结构学习）.chm
数据结构之链表（Java实现）
Easenyang的博客
05-18 8277
数据结构中线性表的重要知识之一
Java数据结构——链表（LinkedList）
最新发布
2201_75685905的博客
07-24 543
在Java中，链表是一种基本的数据结构，用于按照线性方式存储数据集合。与数组不同，链表中的元素在内存中不是连续存储的，而是通过指针（或引用）连接在一起。动态大小：链表的大小可以根据需要动态增长或缩小，不需要像数组那样预先定义固定的大小。元素访问：链表不提供像数组一样的随机访问能力。访问链表中的元素通常需要从头开始遍历。插入和删除操作：在链表中插入或删除元素通常比数组更快，特别是对于不是在链表末尾的操作，因为不需要移动其他元素来腾出空间或填补空位。内存使用。
（java数据结构）链表
AAApple_Y的博客
02-21 704
这里写目录标题三、链表3.1 链表介绍3.2 单链表的应用实例3.3 力扣刷题记录3.3.1 移除链表元素3.3.2 反转链表3.3.3 两两交换链表中的节点3.3.4 删除链表的倒数第N个节点3.3.5 链表相交3.3.6 环形链表 三、链表 3.1 链表介绍 链表是有序的列表，但是它在内存中的存储如下： ​ 小结： ​ 1. 链表是以节点的方式来存储,是链式存储； ​ 2. 每个节点包含 data 域， next 域： 指向下一个节点； ​ 3. 如图： 发现链表的各个节点不一定是连续存
数据结构之链表(java语言实现)
LNsupermali的博客
12-28 3617
数据结构之链表(java语言实现)
Java数据结构：链表
m0_62404808的博客
07-28 318
3）第二种方式在添加英雄时，根据排名蒋英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）（1）单链表查找的方向只能是一个方向，而双向链表可以向前或向后进行查找。（4）链表分带头结点的的链表和没有带头节点的链表，根据实际需求来确定。（2）单链表不能自我删除，需要辅助节点，而双向链表可以进行自我删除。（2）每个节点包含date域，next域指向下一个结点。（2）第一种方法在添加英雄时，直接添加到链表的尾部。（3）链表的结点不一定是连续存储。（1）链表是以节点的方式存储。...
java语言程序设计与数据结构(基础篇)原书第11版 编程题，偶数题目答案
03-01
《Java语言程序设计与数据结构（基础篇）》原书第11版是学习Java编程和数据结构的经典教材。本书深入浅出地介绍了如何利用Java这一强大开发语言来理解和实现各种数据结构，对于初学者和有经验的程序员来说都是宝贵的...
JAVA语言程序设计与数据结构第十一版基础篇答案,java语言程序设计基础篇第十版第十章答案,Java
06-12
《JAVA语言程序设计与数据结构第十一版基础篇答案》主要涵盖了Java编程语言的基本概念、语法和数据结构的运用。本书旨在帮助初学者理解和掌握Java编程的基础知识，并通过解决实际问题来深化对数据结构的理解。以下是...
swift代码-Swift数据结构: 链表(Linked List)
07-14
在Swift编程语言中，数据结构是构建复杂程序的基础，它们帮助我们有效地组织和管理数据。链表是一种重要的数据结构，它的实现方式与数组不同，它不连续存储元素，而是通过节点之间的引用链接来存储。本篇文章将深入...
java数据结构链表
zhangzhongyanting的博客
10-26 260
链表 链表是有序的列表，但是它的内存中是如下图存储的 小结： 1）链表是以节点的方式来存储，是链式存储 2）每一个加点包含data域，next域：指向下一个结点 3）如图：发现链表的各个节点不一定是连续存储 4）链表分为有头节点的和没有头结点的，根据需求来确定自己的设计 单链表如图所示：（带头结点的） 链表很好理解：主要掌握链表的增删改查等操作，话不多说，直接上实例： 使用带head头的单链表实...
Java 链表数据结构
wwxy1995的博客
09-05 183
Java链表实现 链表由链表整体和节点组成 利用链表实现栈 两个栈的测试程序 删除链表中指定元素的递归解法 最简洁写法
java链表数据结构
软件工程
03-23 200
链表
Java链表数据结构
m0_66599327的博客
05-23 175
链表数据结构和数组的横向不同，他是向下延申的，因为他是递归函数的应用。通常在类中定义一个内部类，把内部类当作属性，外部类中存放根节点，运行的时候需要先判断根节点的状态，然后再看是否需要调用根节点下一个节点也就是too.nxet其中too表示当前对象。this.nxet就是当前对象d下一级。 public class DiGui{ public static void main(String []args) { Nodn k = new Nodn(); k.add(1); k.add(
数据结构： JAVA 链表
m0_62319039的博客
10-21 931
链表的基础
Java实现链表数据结构
我的博客
03-27 1238
这是一个用Java实现的链表的数据结构。
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4292
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
Java实现链表（数据结构）
Lotus_dong的博客
12-21 314
数据结构——java实现链表 /** * @author Lotus_dong * @create 2020-12-21 9:56 * @function 链表:真正的动态数组 */ public class MyLinked<T> { /*创建节点,使用内部类*/ private class Node<T> { /*节点元素*/ T element; /*下一个节点*/ Node next;
数据结构链表-java
weixin_65846395的博客
07-18 181
单链表只有一个指向其后续的域，使得单链表只能从前到后依次遍历，要访问某个结点的前驱结点（插入、删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为0(n)。为了一服单链表的上述缺点，引入了双链表，双链表结点中有两个域prev和next域，分别别指向其前驱结点和后继结点。双链表在单链表的结点中增加了一个指向其前驱prev，因此双链表中的按值查找和按位查找的操作与单链表的相同。但双链表在插入和删除操作的实现上，与单链表有着较大的不同。
数据结构基础：链表详解
"这篇资料主要介绍了数据结构中的链表类型，包括循环链表、双向链表，以及链表在数据结构中的应用，并提到了栈和队列的操作特性。此外，资料还强调了数据结构和算法在构建程序中的核心地位，并简述了程序从简单到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值