408考研-数据结构算法-双链表

news2024/9/20 15:02:07

双向链表的存储方式

双向链表跟链表差不多，只是它每个结点都含有两个链——一个指向下一结点，另一个指向前一结点。此外，它还能直接访问第一个和最后一个结点。

单链表只能向后操作，不可以向前操作。为了向前、向后操作方便，可以给每个元素附加两个指针域，一个存储前一个元素的地址，另一个存储下一个元素的地址。这种链表称为双向链表，如图

在这里插入图片描述
在这里插入图片描述
从图中可以看出，双向链表每个节点包含3个域：数据域和两个指针域。两个指针域分别存储前后两个元素节点的地址，即前驱和后继，因此指针指向的类型也是节点类型。

Node{
 int data;
 Node next;
 Node prev;
}

双向链表的基本操作

下面以带头节点的双向链表为例，讲解双向链表的初始化、创建、取值、查找、插入、删除操作。

1．初始化

双向链表初始化是指构建一个空表。先创建一个头节点，不存储数据，然后令其前后两个指针域均为空，如图

在这里插入图片描述
2．创建

创建双向链表也可以用头插法和尾插法。头插法创建的链表和输入顺序正好相反，称为逆序建表；尾插法创建的链表和输入顺序一致，称为正序建表。

头插法建双向链表的过程如下。

1）初始状态是指初始化后的空表，只有一个头节点，前后两个指针域均为空，如图

在这里插入图片描述
2）输入数据元素1，创建新节点，把元素1放入新节点数据域，如图

在这里插入图片描述
3）头插操作，插入头节点的后面，如图

在这里插入图片描述
4）输入数据元素2，创建新节点，把元素2放入新节点数据域，如图

在这里插入图片描述
5）头插操作，插入头节点的后面，如图
在这里插入图片描述
赋值解释

① s->next=L->next：将L节点后面的节点（后继）地址赋值给s节点的指针域，即s节点的next指针指向L的后继节点。

② L->next->prior=s：将s节点的地址赋值给L的后继节点的prior指针域，即L的后继节点的prior指针指向s节点。

③ s->prior=L：将L节点的地址赋值给s节点的prior指针域，即s节点的prior指针指向L节点。

④ L->next=s：将s节点的地址赋值给L节点的指针域，即L节点的next指针指向s节点。

注意：赋值语句的右侧是一个地址，左侧是一个节点的指针域。

修改指针顺序的原则：先修改没有指针标记的那一端

在这里插入图片描述
如果要插入节点的两端都有标记，例如再定义一个指针q指向第1个节点，那么先修改哪个指针都无所谓。实际上，只需要将④语句放在最后修改即可，①②③语句顺序无要求。

拉直链表之后，如图

在这里插入图片描述
6）继续依次输入数据元素3、4、5，头插法创建的双向链表如图
在这里插入图片描述
尾插法建双向链表和尾插法建单链表类似，需要有一个尾指针

/**

 * 双向链表节点类
 */
public class Node {
    int data; //数据节点
    Node prev; //前一个节点
    Node next; //后一个节点

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

public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }
    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }
}    

public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        list.print();
   }
}

3．取值和查找

双向链表的取值、查找和单链表的一样

public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }
    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }


	//在链表中查找节点
	    public Node find(int data){
	        //从链表的头结点开始查找
	        Node current = head;
	        while (current != null){
	            //如果找到了节点数据与目标数据匹配，则返回该节点
	            if(current.data == data){
	                return current;
	            }
	            current = current.next; //否则，继续查找下一个节点
	        }
	        return null;
	    }
	}    


public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

//        list.print();

//        //查找节点
        Node foundNode = list.find(5);
        if(foundNode != null){
            System.out.println("找到了节点: "+ foundNode.data);
        }else{
            System.out.println("未找到节点");
        }
}

4．指定位置插入

单链表只有一个指针域，是向后操作的，不可以向前处理，因此单链表如果在第i个节点之前插入一个元素，就必须先找到第i-1个节点。在第i个节点之前插入一个元素相当于把新节点放在第i-1个节点之后。而双向链表不需要，因为有两个指针，可以向前后两个方向操作，直接找到第i个节点，就可以把新节点插入第i个节点之前。注意：这里假设第i个节点是存在的，如果第i个节点不存在，而第i-1个节点存在，还是需要找到第i-1个节点，将新节点插入第i-1个节点之后，如图

在这里插入图片描述
赋值解释

① p->prior->next=s:s节点的地址赋值给p的前驱节点的next指针域，即p的前驱的next指针指向s。

② s->prior=p->prior:p的前驱的地址赋值给s节点的prior指针域，即s节点的prior指针指向p的前驱。

③ s->next=p:p节点的地址赋值给s节点的next指针域，即s节点的next指针指向p节点。

④ p->prior=s:s节点的地址赋值给p节点的prior指针域，即p节点的prior指针指向s节点。

因为p的前驱无标记，一旦修改了p节点的prior指针，p的前驱就找不到了，因此，最后修改这个指针。实际上，只需要将④语句放在最后修改即可，①②③语句顺序无要求。

修改指针顺序的原则：先修改没有指针标记的那一端。

package com.maweiqi.DoublyLindked;

/**
 * 双向链表类
 */
public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }


    //在制定节点后面插入新节点
    public void insertAfter(Node node , int data){
        if(node == null){
            System.out.println("指定节点为空，插入失败");
            return;
        }

        //创建新节点
        Node newNode = new Node(data);
        //将新节点的前驱指向指定节点
        newNode.prev = node;
        //将新节点的后继指向指定节点的后继
        newNode.next = node.next;
        //如果指定节点有后继，则将后继节点的前驱指向新节点
        if(node.next != null){
            node.next.prev = newNode;
        }
        //将指定节点的后继指向新节点，完成插入操作
        node.next = newNode;
    }

    //在链表中查找节点
    public Node find(int data){
        //从链表的头结点开始查找
        Node current = head;
        while (current != null){
            //如果找到了节点数据与目标数据匹配，则返回该节点
            if(current.data == data){
                return current;
            }
            current = current.next; //否则，继续查找下一个节点
        }
        return null;
    }

  

    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }


}


package com.maweiqi.DoublyLindked;

/**

 */
public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

//        list.print();

//        //查找节点
        Node foundNode = list.find(5);
        if(foundNode != null){
            System.out.println("找到了节点: "+ foundNode.data);
        }else{
            System.out.println("未找到节点");
        }
//
//        //在指定节点后插入新节点
        list.insertAfter(foundNode,5);
        System.out.println("插入节点后的链表为:");
        list.print();

    }
}

5．删除

删除一个节点，实际上是把这个节点跳过去。在单向链表中，必须先找到第i-1个节点，才能把第i个节点跳过去。双向链表不必如此，只要直接找到第i个节点，然后修改指针即可，如图

在这里插入图片描述
p->prior->next=p->next：将p的后继节点的地址赋值给p的前驱节点的next指针域。即p的前驱节点的next指针指向p的后继节点。

注意：等号的右侧是节点的地址，等号的左侧是节点的指针域。

p->next->prior =p->prior：将p的前驱节点的地址赋值给p的后继节点的prior指针域，即p的后继节点的prior指针指向p的前驱节点。此项修改的前提是p的后继节点存在，如果不存在，则不需要此项修改。

这样就把p节点跳过去了，然后用delete p释放被删除节点的空间。删除节点修改指针没有顺序，先修改哪个都可以。

package com.maweiqi.DoublyLindked;

/**
 * 双向链表类
 */
public class DoublyLinkedList {


    //链表的头结点
    Node head;

    //添加节点到链表的尾部
    public void add(int data){
        Node newNode = new Node(data);
        //如果链表为空，泽新节点为头结点
        if(head == null){
            head = newNode;
        }else{
            //要找到链表的尾部
            Node current = head;
            while (current.next != null){
                current = current.next;
            }
            //将新节点的前驱指向当前尾部节点
            newNode.prev = current;
            //将当前尾部节点的后继指向新节点，完成了节点的添加操作
            current.next = newNode;
        }
    }


    //在制定节点后面插入新节点
    public void insertAfter(Node node , int data){
        if(node == null){
            System.out.println("指定节点为空，插入失败");
            return;
        }

        //创建新节点
        Node newNode = new Node(data);
        //将新节点的前驱指向指定节点
        newNode.prev = node;
        //将新节点的后继指向指定节点的后继
        newNode.next = node.next;
        //如果指定节点有后继，则将后继节点的前驱指向新节点
        if(node.next != null){
            node.next.prev = newNode;
        }
        //将指定节点的后继指向新节点，完成插入操作
        node.next = newNode;
    }

    //在链表中查找节点
    public Node find(int data){
        //从链表的头结点开始查找
        Node current = head;
        while (current != null){
            //如果找到了节点数据与目标数据匹配，则返回该节点
            if(current.data == data){
                return current;
            }
            current = current.next; //否则，继续查找下一个节点
        }
        return null;
    }

    //从链表中删除节点
    public void delete(int data){
        //从链表的头结点开始查找
        Node current = head;
        while (current != null){
            //如果我们找到删除的节点
            if(current.data == data){
                //如果是非头节点
                if(current.prev != null){
                    //将要删除的节点的前驱的后继指向要删除节点的后继
                    current.prev.next = current.next;
                }else{
                    //如果是头节点,则更新头结点为要删除节点的后继
                    head = current.next;
                }
                if(current.next != null){
                    //将要删除节点的后继的前驱指向要删除节点的前驱
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next; //每次循环寻找下一个元素
        }
    }

    //打印链表的方法
    public void print(){
        Node current = head;
        while (current != null){
            System.out.println(current.data + " ");
            current = current.next;
        }
    }


}


package com.maweiqi.DoublyLindked;

/**

 */
public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();

        //添加节点
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

//        list.print();

//        //查找节点
//        Node foundNode = list.find(5);
//        if(foundNode != null){
//            System.out.println("找到了节点: "+ foundNode.data);
//        }else{
//            System.out.println("未找到节点");
//        }
//
//        //在指定节点后插入新节点
//        list.insertAfter(foundNode,5);
//        System.out.println("插入节点后的链表为:");
//        list.print();
//
//        //删除节点
        list.delete(2);
        System.out.println("删除节点后的链表");
        list.print();
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/960049.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

表白墙程序

表白墙程序

目录 一、页面代码部分 二、设计程序 二、实现 doPost​编辑 三、实现 doGet 四、前端代码部分 五、使用数据库存储数据 一、页面代码部分 在之前的一篇博客中&#xff0c;已经写过了表白墙的页面代码实现&#xff0c;这里就不再重复了 页面代码如下&#xff1a; <!…
阅读更多...
【Vue2】 axios库

【Vue2】 axios库

网络请求库-axios库 认识Axios库为什么选择Axios库安装Axios axios发送请求常见的配置选项简单请求可以给Axios设置公共的基础配置发送多个请求 axios创建实例为什么要创建axios的实例 axios的拦截器请求拦截器响应拦截器 axios请求封装 认识Axios库 为什么选择Axios库 在游览…
阅读更多...
git学习笔记 | 版本管理 - 分支管理

git学习笔记 | 版本管理 - 分支管理

文章目录 git学习笔记Git是什么仓库常见的命令commit 备注规范在文件下设置git忽略文件 .gitignore 版本管理git log | git reflog 查看提交日志/历史版本版本穿梭 git resetgit reset HEAD <file> git checkout -- fileName 丢弃工作区的修改git revertGit恢复之前版本的…
阅读更多...
海格里斯HEGERLS高密度料箱式四向穿梭车存储系统有哪些显著优势？

海格里斯HEGERLS高密度料箱式四向穿梭车存储系统有哪些显著优势？

近些年仓储货架向着自动化、智能化发展&#xff0c;因此市面上出现很多不同类型的智能自动化仓储货架。其中&#xff0c;最受企业青睐的便是四向穿梭车货架。四向穿梭车货架根据其载重不同可分为托盘式和料箱式两大类。这两种不同类型的四向穿梭车货架在结构形式和控制方式上基…
阅读更多...
Ubuntu20.04下安装google输入法

Ubuntu20.04下安装google输入法

Ubuntu20.04下安装google输入法 1、添加中文语言支持 打开 系统设置——区域和语言——管理已安装的语言——在“语言”tab下——点击“添加或删除语言” 弹出“已安装语言”窗口&#xff0c;勾选中文&#xff08;简体&#xff09;&#xff0c;点击应用 回到“语言支持”窗…
阅读更多...
day 3

day 3

阅读更多...
日本橙皮书数据库—《医疗用医药品质量情报集》

日本橙皮书数据库—《医疗用医药品质量情报集》

日本橙皮书是一份关于医疗用医药品质量情报的汇总报告&#xff0c;由日本厚生劳动省发布。它主要涵盖了药品的品质再评价信息&#xff0c;特别是针对特定历史阶段的产品&#xff0c;笔者总结信息如下&#xff1a; ①日本橙皮书数据库包含了一系列药品的详细信息&#xff0c;如…
阅读更多...
一句话画出动漫效果

一句话画出动漫效果

链接&#xff1a; AI Comic Factory - a Hugging Face Space by jbilcke-hfDiscover amazing ML apps made by the communityhttps://huggingface.co/spaces/jbilcke-hf/ai-comic-factory 选择类型&#xff1a; Japanese 输入提示词&#xff1a; beauty and school love st…
阅读更多...
视频云存储/安防监控/视频AI智能分析网关V3：消防器材缺失检测功能详解

视频云存储/安防监控/视频AI智能分析网关V3：消防器材缺失检测功能详解

在我们的日常生活中&#xff0c;消防器材是必不可少的&#xff0c;无论是在学校、园区还是工厂里&#xff0c;都需要摆放消防器材&#xff0c;做好防范措施&#xff0c;降低安全隐患。但有时也需防备消防器材被人为挪动甚至破坏&#xff0c;在危急时刻无法发挥作用。TSINGSEE青…
阅读更多...
【kubernetes】Argo Rollouts -- k8s下的自动化蓝绿部署

【kubernetes】Argo Rollouts -- k8s下的自动化蓝绿部署

蓝绿（Blue-Green）部署简介 在现代软件开发和交付中，确保应用程序的平稳更新和发布对于用户体验和业务连续性至关重要。蓝绿部署是一种备受推崇的部署策略，它允许开发团队在不影响用户的情况下，将新版本的应用程序引入生产环境。 蓝绿部署的核心思想在于维护两个独立的环…
阅读更多...
lv3 嵌入式开发-1linux介绍及环境配置

lv3 嵌入式开发-1linux介绍及环境配置

目录 1 UNIX、Linux和GNU简介 2 环境介绍 3 VMwareTools配置 4 vim配置&#xff1a; 1 UNIX、Linux和GNU简介 什么是UNIX? unix是一个强大的多用户、多任务操作系统&#xff0c;支持多种处理器架构 中文名 尤尼斯 外文名 UNIX 本质 操作系统 类型 分时操作系统 开…
阅读更多...
数据结构入门 — 栈

数据结构入门 — 栈

本文属于数据结构专栏文章&#xff0c;适合数据结构入门者学习&#xff0c;涵盖数据结构基础的知识和内容体系&#xff0c;文章在介绍数据结构时会配合上动图演示&#xff0c;方便初学者在学习数据结构时理解和学习&#xff0c;了解数据结构系列专栏点击下方链接。 博客主页&am…
阅读更多...
一百七十、Linux——Crontab定时任务调度Kettle脚本

一百七十、Linux——Crontab定时任务调度Kettle脚本

一、目的 由于用海豚调度器调度从Kafka到HDFS的kettle任务时发现有点问题&#xff0c;如果不设置定时调度&#xff0c;这个kettle任务会一直跑&#xff0c;而如果设置定时调度&#xff0c;隔天后就会生成多个任务&#xff0c;而且每个任务都在跑&#xff0c;不会停下&#xff…
阅读更多...
stable diffusion实践操作-提示词

stable diffusion实践操作-提示词

本文专门开一节写提示词相关的内容&#xff0c;在看之前&#xff0c;可以同步关注&#xff1a; stable diffusion实践操作 正文 提示词是SD中非常重要&#xff0c;你生成的图片质量&#xff0c;基本就取决于提示词的好坏&#xff0c;提示词分为正向提示词和反向提示词。 模板…
阅读更多...
激光切割机自动调焦技术详解加图解

激光切割机自动调焦技术详解加图解

激光切割机在切割不同材料的过程中&#xff0c;激光束的焦点必须根据要求位于材料的不同位置。 因此&#xff0c;在切割不同材料的物料时&#xff0c;需要调整激光切割机的焦点位置。在以前的生产激光切割机中&#xff0c;普遍采用手动调焦的方法进行调焦。现在&#xff0c;许多…
阅读更多...
【Docker】用Dockerfile制作个人的镜像文件

【Docker】用Dockerfile制作个人的镜像文件

作者简介&#xff1a; 辭七七&#xff0c;目前大一&#xff0c;正在学习C/C&#xff0c;Java&#xff0c;Python等 作者主页&#xff1a; 七七的个人主页 文章收录专栏&#xff1a; 七七的闲谈 欢迎大家点赞 &#x1f44d; 收藏 ⭐ 加关注哦&#xff01;&#x1f496;&#x1f…
阅读更多...
stable diffusion实践操作-常见lora模型介绍

stable diffusion实践操作-常见lora模型介绍

本文专门开一节写Lora相关的内容&#xff0c;在看之前&#xff0c;可以同步关注&#xff1a; stable diffusion实践操作 模型分两种&#xff0c;一种是sd大模型&#xff0c;一种是类似Lora的小模型 国内的是&#xff1a;https://www.liblibai.com 国外的是&#xff1a;https:/…
阅读更多...
企业数字化建设-采购平台规划方案PPT（附数字化建设方案300份)

企业数字化建设-采购平台规划方案PPT（附数字化建设方案300份)

本资料来源公开网络&#xff0c;仅供个人学习&#xff0c;请勿商用&#xff0c;如有侵权请联系删除&#xff0c;更多浏览公众号&#xff1a;智慧方案文库 46页《智慧书店数字化转型解决方案》.pdf8页德勒数字化智能制造解决方案.pdf24页数字化智能化车间规模与建设.pdf数字化校…
阅读更多...
【C++】C++11新特性（下）

【C++】C++11新特性（下）

上篇文章&#xff08;C11的新特性&#xff08;上&#xff09;&#xff09;我们讲述了C11中的部分重要特性。本篇接着上篇文章进行讲解。本篇文章主要进行讲解&#xff1a;完美转发、新类的功能、可变参数模板、lambda 表达式、包装器。希望本篇文章会对你有所帮助。 文章目录 一…
阅读更多...
【整数列表求三的倍数】

【整数列表求三的倍数】

问题描述: 给定一个从1到n的整数列表&#xff0c;从第一个数字开始计数&#xff0c;遇到3的倍数时&#xff0c;将该数从列表中删除&#xff0c;直至列表末尾。 在剩下的数字中&#xff0c;从第一个数字开始&#xff0c;继续之前的计数值&#xff0c;同样遇到3的倍数时&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023