数据结构-双链表思路解析及代码实现

已于 2022-11-20 15:16:00 修改
阅读量557 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构
于 2022-11-19 22:31:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dfBeautifulLive/article/details/127933690
版权

双链表是单链表的进阶版，单链表是1-2-3-4 一个个排排坐链接，只管向后拉手，其主要思想是当前节点与下一节点的关系，那么双链表就多了一层关系，当前节点不仅和一下一点连起来，也要和上一节点串联起来。与前与后都要拉手。

如果对单链表不熟悉，建议先去看看单链表实现方式，链接如下

单链表实现代码以及解析

咱们还是先以定义节点开始，单链表是有当前节点和下一个节点的定义，那双向链表就需要有上一节点的定义，那就可以如下代码表现：

 public class DoubleLinked<E> {

    // 定义一个内部节点类
    private static class Node<E> {
        // 当前节点
        E item;
        // 上一节点
        Node<E> prev;
        // 下一节点
        Node<E> next;

        public Node(E item,  Node<E> prev,Node<E> next) {
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }
}

1.添加节点

有了节点的定义就可以操作了，咱们先来添加操作

添加节点默认添加到尾部，所以调用linkLast方法，我们假如要添加1-2-3，我们要考虑添加了1以后，需要把2添加到1后，添加到3以后需要考虑2添加到3前等情况，咱们来逐个分析。

存储第一个节点时

1.我们需要实例化一个1的节点，因为不知道上一个节点值所以prev需要为空，也因为不知道下一个节点值所以next值需要为空，这样第一个值也就设置好了，那么设置好的值存储在哪里呢？才能把后面的值串连在一起，这时我们用全局变量first节点做这个事情

存储中间节点时

假设第一个节点存储好，那么添加第二个节点为2的值，操作又是什么？

当前节点为2的时候需要知道上一个节点值是1，下一个节点仍然不知道所以为空，所以构造方法就是 new Node(2,1,null)，但是怎么知道上一个节点的值呢，这时候就需要添加个全局变量last，用来存储最后一个值，当第一个节点1存储进来时将1存储到last，第二个节点2过来的时候则直接用last也就是1就可， 用完后将last改为2，后面都以此种方式，就保证了last相比最新值时为上一个值。

    // 首值
    private Node first;
    // 最后值
    private Node last;
    private int size;

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    // 1-2-3
    void linkLast(E e) {
        // 上一个值，在第一次存储时为空
        Node l = last;
        // 新节点
        Node newNode = new Node(e, last, null);
        // 将新节点赋值给last
        last = newNode;
        // 第一次存储直接赋值给first即可
        if (l == null) {
            first = newNode;
        } else {
            // 通过引用类型的概念，此种方式则可让first串起来
            // 第二次及以后的值需要将上一个值的next设置为当前新的节点
            l.next = newNode;
        }
        size++;
    }

    // 打印链表数据
    private void printData() {
        Node f = null;
        for (int i = 0; i < size; i++) {
            if (i == 0) {
                System.out.print(first.item);
                f = first.next;
            } else {
                System.out.print("-" + f.item);
                f = f.next;
            }

        }
        System.out.println("");
    }
   public static void main(String[] args) {
        DoubleLinked doubleLinked = new DoubleLinked();
        doubleLinked.add("1");
        doubleLinked.add("2");
        doubleLinked.add("3");

        doubleLinked.printData();
        System.out.println("添加完毕-----------");
    }

 结果：

2.查询元素

根据小标索引查询链表数据，它这里用了将当前的链表长度除2，如果你要搜索的索引小于我计算过后的数字就证明你要找的位置比较靠前，所以就从头开始向后找（也就是说从first全局变量里循环取出next的数据），如果相反则证明你要找的数据在中后部分，需要从后向前找(也就是从last全局变量循环取出prev数据)，还算蛮简单的哈。

  // 根据索引获取链表元素
 public E get(int index) {
     return node(index).item;
 }  

 Node<E> node(int index) {
        // 右移1位相当于除以2
        int i = size >> 1;
        // 如果要找的索引不大于i，则从前往后找最快
        if (index < i) {
            Node find = first;
            for (int i1 = 0; i1 < index; i1++) {
                find = find.next;
            }
            return find;
        } else {
            // 如果要找的索引大于i，则从后往前找更快
            Node find = last;
            for (int i1 = size - 1; i1 > index; i1--) {
                find = find.prev;
            }
            return find;
        }
    }

 3.删除

删除节点，毋庸置疑我们要移动前后节点，挤出待删除节点。

待删除为中间节点的话：

 比如1-2-3-4-5 我需要将2删除，索引就是1，需要将2的前一个节点也就是1找到，然后将1的下一个节点改为3，将2的下一个节点3找到，将3的上一个节点改为1，这样2的这个节点自然就删除了，这是删除中间的链表

待删除是头节点第一个的话：

假如1-2-3-4-5 删除的是1，索引就是0，此时1的节点上一个是空，这时需要找到当前节点的下一个节点直接赋值头节点即可。

待删除是最后一个节点的话：

假如1-2-3-4-5 删除的是5，索引就是4，此时下一个节点就是空，这时需要找到当前节点的上一个节点置为空即可。

    // 1-2-3-4-5
    public boolean remove(int index) {
        // 得到待删除的节点
        Node node = node(index);
        // 得到删除的节点前一个节点
        Node prev = node.prev;
        // 得到删除的节点后一个节点
        Node next = node.next;
        // 当前节点前一个为空，则证明要删除第一个，直接将当前值下一个节点覆盖first即可
        if (prev == null) {
            first = next;
        } else {
            // 给上一个节点的next节点改成当前节点的下一个
            prev.next = next;
            if (next != null) {
                // 给下一个节点的prev节点改成当前节点的上一个
                next.prev = prev;
            }
        }
        size--;
        return true;
    }
public static void main(String[] args) {
        DoubleLinked doubleLinked = new DoubleLinked();
        doubleLinked.add("1");
        doubleLinked.add("2");
        doubleLinked.add("3");
        doubleLinked.add("4");
        doubleLinked.add("5");

        doubleLinked.printData();
        System.out.println("添加完毕-----------");

        System.out.println("查找元素2：" + doubleLinked.get(1));
        System.out.println("查找元素1：" + doubleLinked.get(0));
        System.out.println("查找元素3：" + doubleLinked.get(2));


        System.out.println("删除2：" + doubleLinked.remove(1));
        System.out.println("删除3：" + doubleLinked.remove(1));
        System.out.println("删除1：" + doubleLinked.remove(0));
        doubleLinked.printData();

    }

 

4.更新节点

更新节点比较简单，不用移动前后距离，直接找到当前节点并更新就好

    // 更新节点
    public E set(int index, E element) {
        Node<E> currentNode = node(index);
        // 找到当前节点
        E oldValue = currentNode.item;
        // 直接更新当前的节点
        currentNode.item = element;
        return oldValue;
    }

整体代码：

package linkedList;

import java.util.LinkedList;

/**
 * @Author df 双链表实现
 * @Date 2022/11/19 10:47
 * @Version 1.0
 */
public class DoubleLinked<E> {

    // 定义一个内部节点类
    private static class Node<E> {
        // 当前节点
        E item;
        // 上一节点
        Node<E> prev;
        // 下一节点
        Node<E> next;

        public Node(E item, Node<E> prev, Node<E> next) {
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }

    // 首值
    private Node first;
    // 最后值
    private Node last;
    private int size;

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    // 1-2-3
    void linkLast(E e) {
        Node l = last;
        Node newNode = new Node(e, last, null);
        last = newNode;
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
    }

    // 根据索引获取链表元素
    public E get(int index) {
        return node(index).item;
    }

    // 1-2-3-4-5
    public boolean remove(int index) {
        // 得到待删除的节点
        Node node = node(index);
        // 得到删除的节点前一个节点
        Node prev = node.prev;
        // 得到删除的节点后一个节点
        Node next = node.next;
        // 当前节点前一个为空，则证明要删除第一个，直接将当前值下一个节点覆盖first即可
        if (prev == null) {
            first = next;
        } else {
            // 给上一个节点的next节点改成当前节点的下一个
            prev.next = next;
            if (next != null) {
                // 给下一个节点的prev节点改成当前节点的上一个
                next.prev = prev;
            }
        }
        size--;
        return true;
    }


    // 更新节点
    public E set(int index, E element) {
        Node<E> currentNode = node(index);
        // 找到当前节点
        E oldValue = currentNode.item;
        // 直接更新当前的节点
        currentNode.item = element;
        return oldValue;
    }

    Node<E> node(int index) {
        // 右移1位相当于除以2
        int i = size >> 1;
        // 如果要找的索引不大于i，则从前往后找最快
        if (index < i) {
            Node find = first;
            for (int i1 = 0; i1 < index; i1++) {
                find = find.next;
            }
            return find;
        } else {
            // 如果要找的索引大于i，则从后往前找更快
            Node find = last;
            for (int i1 = size - 1; i1 > index; i1--) {
                find = find.prev;
            }
            return find;
        }
    }

    private void printData() {
        Node f = null;
        for (int i = 0; i < size; i++) {
            if (i == 0) {
                System.out.print(first.item);
                f = first.next;
            } else {
                System.out.print("-" + f.item);
                f = f.next;
            }
        }
        System.out.println("");
    }

    public static void main(String[] args) {
        DoubleLinked doubleLinked = new DoubleLinked();
        doubleLinked.add("1");
        doubleLinked.add("2");
        doubleLinked.add("3");
        doubleLinked.add("4");
        doubleLinked.add("5");

        doubleLinked.printData();
        System.out.println("添加完毕-----------");

        System.out.println("查找元素2：" + doubleLinked.get(1));
        System.out.println("查找元素1：" + doubleLinked.get(0));
        System.out.println("查找元素3：" + doubleLinked.get(2));


        System.out.println("删除2：" + doubleLinked.remove(1));
        System.out.println("删除3：" + doubleLinked.remove(1));
        System.out.println("删除1：" + doubleLinked.remove(0));
        doubleLinked.printData();

        System.out.println("更改元素5为6：" + doubleLinked.set(1,"6"));
        doubleLinked.printData();

    }
}

 

 

PromisingGirl-Du
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表（含全部实现代码）
qq_45967533的博客
03-12 7102
本篇的内容是对链表的一个介绍，并且会使用C语言实现链表的几个主要接口。 目录链表的概念与结构 链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 一个链表由n个节点组成，每一个节点都是一个结构体，这个结构体里的一个成员是该节点存储的数据，另一个成员是指向下一个节点的指针。 其结构如下 上图只是一种结构的链表，并不是所有的链表都是这样的结构，在实际中链表的结构非常多样，有以下几种情况：是否带头，单向还是双向，是否循环。共23=8种
数据结构-链表基础详解(超详细代码)
mayu_xuan的博客
12-04 3097
链表的定义及代码包含顺序表和单链表 目录一、线性表 1.线性表定义2.线性表特点二、线性表的顺序表示（顺序表）1、顺序表的优缺点2.插入操作3.删除操作4.练习三、线性表的链式表示（单链表）1.单链表定义2.单链表优缺点3.插入操作4.删除操作 5.查找操作5.1按序号查找结点 5.2按值查找结点 6.练习 1、顺序表的优缺点 1.优点：最好情况：在表尾插入元素，不需要移动元素，时间复杂度
简单一文带你了解链表结构--附完整代码
gentle_zou的博客
09-09 1102
非常简单好理解的链表教程
数据结构之单链表（c语言附完整代码）
热门推荐
m0_62795460的博客
11-01 1万+
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。声明单链表//数据域 struct LNode * next;//指针域，指向后继结点 } LinkNode;//声明单链表结点类型注意：本文章讨论的单链表是带头结点的单链表。
【数据结构与算法】 - 双向链表 - 详细实现思路及代码
wkd_007的博客
04-12 4549
介绍双向链表，以及双向链表的详细实现步骤，最后提供了C语言实现双向链表的代码
leetcode答案-leetcode-[removed]leetcode
06-30
分类经典题目的解析，包括思路，关键点和具体的代码实现。 第二部分是对于数据结构的总结 第三部分是对于算法的总结 leetcode 分类经典题目的解析 数组和字符串相关题目 简介： 数组是一种基本的数据结构，用于按...
leetcode答案-leetcode:记录自己的算法成长
06-30
经典题目的解析，包括思路，关键点和具体的代码实现； 第三部分是公司攻克。 只有熟练掌握基础的数据结构与算法，才能对复杂问题迎刃有余。 数据结构与算法 概述 其中算法，主要是以下几种： 基础技巧：分治、二分、...
高级C语言详解
08-18
33. 二叉树的数据结构 167 34. 位运算应用口诀和实例 170 35. 内存对齐与ANSI C中struct内存布局 173 36. 冒泡和选择排序实现 180 37. 函数指针数组与返回数组指针的函数 186 38. 右左法则- 复杂指针解析 189 39. ...
免费下载:C语言难点分析整理.doc
02-29
33. 二叉树的数据结构 167 34. 位运算应用口诀和实例 170 35. 内存对齐与ANSI C中struct内存布局 173 36. 冒泡和选择排序实现 180 37. 函数指针数组与返回数组指针的函数 186 38. 右左法则- 复杂指针解析 189 39. ...
c语言难点分析整理，C语言
10-24
33. 二叉树的数据结构 167 34. 位运算应用口诀和实例 170 35. 内存对齐与ANSI C中struct内存布局 173 36. 冒泡和选择排序实现 180 37. 函数指针数组与返回数组指针的函数 186 38. 右左法则- 复杂指针解析 189 39. ...
数据结构单链表最全的实现代码
12-04
数据结构入门级必看的单链表，内含单链表比较全的算法实现源代码。
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6064
单链表的操作与实现
【链表】单链表知识总结-内含代码操作及其说明
qq_53830608的博客
01-06 1874
认识链表： 顺序表：逻辑相邻，物理也相邻（例如数组，坐在旁边的一定是舍友） 链表：逻辑相邻，物理不一定相邻（坐在旁边的也不一定是舍友）//不能从第一个数一直遍历到最后一个数 链表就是线性表的链式表述。 因此，链表结点的意义：存放数据+下一个结点的地址 ①结点定义代码如下： typedefintElemType; typedefstructNode { ElemTypedata;//存放数据 structNode* next;// 存放...
C语言链表代码总结
weixin_51772979的博客
03-11 419
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序就是通过链表中的指针链接次序实现的。它相比于线性表的顺序存储结构，链式存储结构（即链表）在每一次插入和删除元素时，时间效率都得到了大大的提高，因此学习链表对于我们在数据的处理上有很大的帮助。在平时的使用中，链表通常分为单链表和双链表，但一般单链表懂了双链表也自然能理解。
【数据结构】第二站：C语言--单链表（附完整源码和注释）
最新发布
poplar的博客
04-17 1341
进入链表，链表根据单/双向，是否循环，是否有哨兵位可分成多种，我们只重点选择几个解析，触类旁通，这篇文章的单链表没有带哨兵位的单链表，实现会有很多困难，也正是因为这种结构有问题，所以很容易取得出题者的青睐，单链表实现函数的参数开始使用二级指针，亲自画图成为理解单链表断言、结构的最快方法。
猿创征文｜数据结构-单链表详解（含完整代码）
qq_65641647的博客
09-12 1308
数据结构-单链表详解，包含单链表代码，包含图片解析，一看就会的单链表。
数据结构与算法(一) 链表（代码示例）
码出精彩
08-19 716
数据结构与算法1. 什么是单链表2. 实现单链表的增删操作1. 插入单链表第i个结点，即插入到ai-1与ai之间的具体步骤：2. 删除第i个结点3. 删除链表的重复数据4. 找出单链表中的倒数第k个元素5. 实现链表的反转6. 从尾到头输出单链表7. 查找单链表的中间结点8. 检测一个链表是否有环9. 在不知道头指针的情况下删除指定结点10. 判断两个链表是否相交11. 总结 1. 什么是单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每
数据结构学习（C语言）之链表代码
DLUT_yan的博客
04-16 9175
（郝斌老师视频课） 简介： 24_链表创建和链表遍历算法的演示 25_判断链表是否为空和求链表长度算法的演示 26_通过链表排序算法的演示再次详细讨论到底什么是算法以及到底什么是泛型【重点】 27_如何学习算法自己的一些感想 28_链表插入和删除算法的演示 29_复习 24_链表创建和链表遍历算法的演示 创建一个节点的结构体： typedef struct Node { int data;//数...
【数据结构】单链表完整代码实现
飞舞的蓝色雪花
11-21 4092
数据结构中单链表的完整代码实现。
java数据结构-循环链表的设计与实现
03-16
循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成...总之，循环链表是一种非常有用的数据结构，可以在很多场景中使用。在Java中，我们可以通过定义Node类和头节点、尾节点来实现循环链表的设计与实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值