链表？or 双向链表？

最新推荐文章于 2024-08-17 16:47:39 发布
最新推荐文章于 2024-08-17 16:47:39 发布
阅读量57 收藏 1
点赞数 1
文章标签： 链表 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79181607/article/details/131861583
版权
本文详细介绍了如何在Java中创建和操作链表，包括单链表和双向链表。首先讲解了栈区和堆区的概念，然后展示了两种创建链表节点的方法。接着，文章阐述了链表的遍历、插入（首部、中部、尾部）和删除（首部、尾部、中部）的操作。对于双向链表，文章特别提到了其结构和如何进行首尾插入、删除以及中间插入和删除。
摘要由CSDN通过智能技术生成

1. 单链表

1.1 创建链表

在JVM中，栈区存放的是引用（这里我理解为指针），堆区存放的才是创建的对象。

链表访问结构

使用Java创建链表结点的方式有两种，一种是根据面向对象思想去创建链表结点，还有一种则是违背面向对象思想，采用一种更精简的方式去创建链表结点。

根据面向对象思想去创建链表结点：

public class LinkNode {
    private int data;
    private LinkNode next;

    // 构造方法
    public LinkNode(int data) {
        this.data = data;
    }

    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public LinkNode getNext() {
        return next;
    }
    public void setNext(LinkNode next) {
        this.next = next;
    }
}

违背面向对象思想，采用一种更精简的方式去创建链表结点：

public class LinkNode {
    public int val;
    public LinkNode next;

    LinkNode(int x) {
        val = x;
        next = null; // 可以不写，写上更规范
    }
}

1.2 遍历链表

对于单链表，一定是从头开始逐个向后访问，所以操作之后一定要确保还能找到表头。

/**
 * 获取链表长度
 * @param head 头结点
 * @return 链表长度
 */
public static int getListLength(Node head) {
    int length = 0;
    Node node = head;
    while (node != null) {
        length++;
        node = head.next;
    }
    return length;
}

1.3 链表插入

单链表的插入需要考虑到三种情况：首部、中部、尾部。

（1）在链表的首部插入

需要注意从首部插入后要将head指向新插入的结点。

在链表的首部插入

（2）在链表的中部插入

需要注意的是遍历时要在插入的前一个位置停下。

在链表的中部插入

（3）在链表的尾部插入

只需要将尾结点指向新的结点就可以了。

在链表的尾部插入

（4）编码
/**
 * 链表插入
 * @param head 头结点
 * @param nodeInsert 要插入的结点
 * @param position 要插入的位置
 * @return 新链表的头结点
 */
public static Node insertNode(Node head, Node nodeInsert, int position) {
    // 1. 判断当前链表是否是一个空链表
    if (head == null) {
        return nodeInsert;
    }

    // 2. 判断要插入的位置是否越界
    int size = getListLength(head);
    if (position > size + 1 || position < 1) {
        System.out.println("位置参数越界");
        return head;
    }

    // 3. 插入结点
    // 当插入位置是头部的情况时
    if (position == 1) {
        nodeInsert.next = head;
        // 这里可以直接写 return nodeInsert; 也可以像下面这么写
        head = nodeInsert;
        return head;
    }

    Node pNode = head;
    int count = 1;

    while (count < position - 1) {
        pNode = pNode.next;
        count++;
    }
        
    nodeInsert.next = pNode.next;
    pNode.next = nodeInsert;
        
    return head;
}

1.4 链表删除

同样要考虑到三种情况：首部、中部、尾部。

（1）删除表头结点

只要将head向前移动一个就行，JVM会自动回收到不可达的结点。

删除表头结点

（2）删除最后一个结点

删除最后一个结点

（3）删除中间的结点

删除中间的结点

（4）编码
/**
 * 链表删除
 * @param head 头结点
 * @param position 要删除结点的位置
 * @return 新链表的头结点
 */
public static Node deleteNode(Node head, int position) {
    // 1. 判断当前链表是否是一个空链表
    if (head == null) {
        return null;
    }

    // 2. 判断要删除的位置是否越界
    int size = getListLength(head);
    if (position > size || position < 1) {
        System.out.println("位置越界");
        return head;
    }

    // 3. 删除结点
    if (position == 1) {
        return head.next;
    } else {
        Node pNode = head;
        int count = 1;

        while (count < position - 1) {
            pNode = pNode.next;
            count++;
        }
        Node curNode = pNode.next;
        pNode.next = curNode.next;
    }
    return head;
}

2. 双向链表

2.1 基本概念

双向链表

2.2 创建、遍历链表

public class DoubleLink {
    // 双向链表的结构
    private DoubleNode first;
    private DoubleNode last;

    public DoubleLink() {
        first = null;
        last = first;
    }

    /**
     * 定义结点类
     */
    public static class DoubleNode {
        public int data;
        public DoubleNode next;
        public DoubleNode prev;

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

        // 打印结点的数据域
        public void displayNode() {
            System.out.println("{" + data + "}");
        }
    }

    /**
     * 从头部遍历打印
     */
    public void displayForward() {
        System.out.println("List(first---->last): ");
        DoubleNode current = first;
        while (current != null) {
            current.displayNode();
            current = current.next;
        }
        System.out.println();
    }

    /**
     * 从尾部遍历打印
     */
    public void displayBackward() {
        System.out.println("List(last---->first): ");
        DoubleNode current = last;
        while (current != null) {
            current.displayNode();
            current = current.prev;
        }
        System.out.println();
    }
}

2.3 链表插入

首尾插入要比中间插入简单，中间插入的图像为：

双向链表中间插入结点

public class DoubleLink {
    // 双向链表的结构
    private DoubleNode first;
    private DoubleNode last;

    public DoubleLink() {
        first = null;
        last = first;
    }

    /**
     * 定义结点类
     */
    public static class DoubleNode {
        public int data;
        public DoubleNode next;
        public DoubleNode prev;

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

        // 打印结点的数据域
        public void displayNode() {
            System.out.println("{" + data + "}");
        }
    }

    /**
     * 从头部遍历打印
     */
    public void displayForward() {
        System.out.println("List(first---->last): ");
        DoubleNode current = first;
        while (current != null) {
            current.displayNode();
            current = current.next;
        }
        System.out.println();
    }

    /**
     * 从尾部遍历打印
     */
    public void displayBackward() {
        System.out.println("List(last---->first): ");
        DoubleNode current = last;
        while (current != null) {
            current.displayNode();
            current = current.prev;
        }
        System.out.println();
    }

    /**
     * 判断链表是否为空
     * @return 布尔值
     */
    public boolean isEmpty() {
        return first == null || last == null;
    }

    /**
     * 在头部插入结点
     * @param data 结点数据
     */
    public void insertFirst(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (isEmpty()) {
            last = newDoubleNode;
        } else {
            first.prev = newDoubleNode;
        }
        newDoubleNode.next = first;
        first = newDoubleNode;
    }

    /**
     * 在尾部插入结点
     * @param data 插入的结点数据
     */
    public void insertLast(int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        if (isEmpty()) {
            first = newDoubleNode;
        } else {
            newDoubleNode.prev = last;
            last.next = newDoubleNode;
        }
        last = newDoubleNode;
    }

    /**
     * 在中间插入结点
     * @param key 在对应数据为key的结点后面插入
     * @param data 要插入的结点的数据
     */
    public void insertAfter(int key, int data) {
        DoubleNode newDoubleNode = new DoubleNode(data);
        DoubleNode current = first;

        while (current != null && current.data != key) {
            current = current.next;
        }

        // 如果当前结点为null
        if (current == null) {
            // 判断是不是空链表
            if (isEmpty()) {
                first = newDoubleNode;
                last = newDoubleNode;
            } else {
                // 找不到key的值，就在最后插入一个结点
                newDoubleNode.prev = last;
                last.next = newDoubleNode;
                last = newDoubleNode;
            }
        } else {    // 找到了key的值，分情况讨论
            if (current == last) {
                // key的值和最后结点的data相等
                newDoubleNode.next = null;
                last = newDoubleNode;
            } else {
                // 在两个结点中间插入
                newDoubleNode.next = current.next;
                current.next.prev = newDoubleNode;
            }
            newDoubleNode.prev = current;
            current.next = newDoubleNode;
        }

    }
}

2.4 链表删除

同样的，首尾删除要比中间删除简单，中间删除的图像为：

双向链表中间删除结点

/**
     * 删除首结点
     * @return 删除的结点
     */
    public DoubleNode deleteFirst() {
        DoubleNode temp = first;
        // 如果链表只有一个结点
        if (first.next == null) {
            last = null;
        } else {
            // 两个以上的结点
            first.next.prev = null;
        }
        first = first.next;
        return temp;
    }

    /**
     * 删除尾结点
     * @return 删除的结点
     */
    public DoubleNode deleteLast() {
        DoubleNode temp = last;
        if (last.prev == null) {
            first = null;
        } else {
            last.prev.next = null;
        }
        last = last.prev;
        return temp;
    }

    /**
     * 删除中间结点
     * @param key 对应删除结点的key
     * @return 删除的结点
     */
    public DoubleNode deleteKey(int key) {
        DoubleNode current = first;
        while (current != null && current.data != key) {
            current = current.next;
        }

        // 如果current为null
        if (current == null) {
            return null;
        } else {
            // 如果current是第一个结点
            if (current == first) {
                first = current.next;
                current.next.prev = null;
            } else if (current == last) {
                // 如果current是最后一个结点
                last = current.prev;
                current.prev.next = null;
            } else {
                // current在中间
                current.prev.next = current.next;
                current.next.prev = current.prev;
            }
        }
        
        return current;
    }
张小yu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
实现一个双向链表的倒置功能（1->2->3 变成 3->2->1)
04-15
双向链表是链表的一种变体，每个节点不仅包含数据，还包含指向下一个节点和前一个节点的指针。在本题中，我们需要实现一个功能，将给定的双向链表（1->2->3）倒置，使其变为（3->2->1）。 双向链表的基本结构包括...
链表对两位数操作
11-11
链表分为单向链表和双向链表，前者每个节点仅包含指向下一个节点的指针，后者则包含两个指针，分别指向前后两个节点。 对于"链表对两位数操作"的问题，我们首先需要创建一个链表节点，这个节点应包含一个表示两位数...
链表？细啊！超详细的知识点总结！
那仰望的人，心底的孤独和叹息
01-29 9587
超级详细的链表知识点总结笔记。图文并茂，各个功能代码都有。单链表反转详细解答，递归法，迭代法。双向链表，约瑟夫环问题。反转部分链表，充分理解递归思想
python双向链表以及双向循环链表
tt丫的博客
01-29 1466
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 目录 一、双向链表和双向循环链表概念 二、双向链表的实现 1、建立节点对象 2、链表对象的初始定义 3、判断链表是否为空 4、获取链表长度 5、向头部添加节点 6、向尾部添加节点 7、指定位置插入节点 8、删除指定位置的节点 9、查找是否有该数据的节点 10、遍历输出整个链表 11、输入数据创建链表 12、具体调用 三、双向循环链表的实现 1、建立节点对象 2
数据结构双向链表学习
fengjuju的博客
05-02 1278
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
什么是双向链表，一篇搞懂双向链表
hahaha_1112的博客
03-12 968
双向链表，python3
Rust实现双向链表LinkedList
qq_19266669的博客
12-29 767
Rust实现双向链表LinkedList。
数据结构单向链表、单向循环链表、双向链表、双向循环链表操作
weixin_62318298的博客
07-24 295
本文对单向链表，单向循环链表，双向链表，双向循环链表进行了完整操作
双向链表的插入
ulm23的博客
07-28 975
双向链表插入
【链表-双向链表】
m0_63715738的博客
05-04 685
本文介绍了双向链表
Go语言数据结构（一）双向链表
qq_47997583的博客
01-15 1042
Go语言中list容器定义在"container/list"包中，实现了一个双向链表。本文第一部分总结源码包中的方法，第二部分展示使用list包的常见示例用法以及刷题时的用法。
Linked.zip
06-02
在IT领域，数据结构是编程基础中的重要组成部分，而双向链表是一种常用的数据结构，它在许多场景下有着广泛的应用。本文将详细讲解双向链表的实现，以及如何进行增、删、改、查操作。 双向链表不同于单向链表，它在...
链表实现学生管理
01-17
①(1) 选用线性表（静态表/动态表 Array or linked list : 单向链表/双向链表/双向循环链表） ②(2) 非线性结构实现： 二叉搜索树（Binary Search Tree） ③(3) 非线性结构实现： AVL树 ④(4) 非线性...
链表的C语言实现之删除结点.rar_c语言前驱节点
09-23
链表是一种基础且重要的数据结构，它在计算机科学中被广泛应用，特别是在内存管理、文件系统、数据库等场景。...通过理解和应用这些基本操作，可以进一步理解更复杂的链表结构，如双向链表、循环链表等。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 681
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构----链表
新手嵌入式学习的博客
08-16 1199
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构：栈
最新发布
2301_80744520的博客
08-17 336
顺序栈的表示存储方式：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址。top：指示栈顶元素位置base：指示栈底元素位置stacksize：表示栈的最大容量接下来，我们用更详细的一幅图来描述顺序栈：起始状态，top和base都指向0的位置，此时是空栈：base==top，且栈的容量stacksize=4。接下来为空的栈添加元素（入栈），将新的元素添加到top所指位置，再将top移向下一位置，我们最终可以观察到top并没有指向D，而是栈的外面，即4的位置。
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 244
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
双向链表双向冒泡排序
12-21
双向链表的双向冒泡排序可以通过比较相邻节点的数据域来实现。具体步骤如下： 1. 首先，定义一个指向链表头节点的指针，命名为`current`。 2. 使用两个循环嵌套，外层循环控制比较的轮数，内层循环控制每一轮的比较...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

张小yu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值