数据结构-JAVA中带头节点的单向双向链表的CRUD操作

最新推荐文章于 2023-03-20 20:56:18 发布
原创 最新推荐文章于 2023-03-20 20:56:18 发布 · 370 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #链表 #数据结构 #算法 #单链表

本文深入探讨了单向链表和双向链表的创建、读取、更新和删除（CRUD）操作，重点讲解了在单向链表中辅助指针的正确使用方法，以及双向链表中更为简洁的实现方式。通过具体代码示例，对比了两种链表类型在操作上的差异。

个人感悟：在单向链表的CRUD中需要更加注意辅助指针的指向，比如在删除节点时，无法直接删除辅助指针指向的节点，因为无法找到前一个节点，并让其指向当前节点的后一个节点。此时的解决方法就是永远让你的辅助指针在你想要比较的节点的前面一个节点，这样就可以轻松让前一个节点指向后一个节点了。
而在双向链表中则没有这种担忧，直接干就完了。
（最后更新时间 2020/8/22 2：24）

以下为带头节点的链表（双向链表处的代码更加凝练）

单向链表的增删改查操作

package 单链表.基础;

import java.util.Stack;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //进行测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(3, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(5, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(7, "林冲", "豹子头");
        HeroNode hero5 = new HeroNode(2, "宋江2", "及时雨2");
        HeroNode hero6 = new HeroNode(4, "卢俊义2", "玉麒麟2");
        HeroNode hero7 = new HeroNode(6, "吴用2", "智多星2");
        HeroNode hero8 = new HeroNode(8, "林冲2", "豹子头2");

        //创建要给链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        SingleLinkedList singleLinkedList2 = new SingleLinkedList();

        //加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList2.addByOrder(hero5);
        singleLinkedList2.addByOrder(hero6);
        singleLinkedList2.addByOrder(hero8);
        singleLinkedList2.addByOrder(hero7);

        singleLinkedList.update(4,"被修改");

//        singleLinkedList.del(1);

//        System.out.println(getLength(singleLinkedList.head));

//        try {
//            System.out.println(findLastIndexNode(1,singleLinkedList.head));
//        }catch (Exception e){
//            System.out.println(e.getMessage());
//        }

//        reversePrint(singleLinkedList.head);

        mergeLinkedList(singleLinkedList,singleLinkedList2.head);

        singleLinkedList.list();
//        singleLinkedList2.list();

//        reversetList(singleLinkedList.head);
//        singleLinkedList.list();
    }

    //统计链表内节点的个数
    public static int getLength(HeroNode head){
        if (head.next == null){
            return 0;
        }
        int length = 1;
        HeroNode cur = head.next;
        while (true){
            if (cur.next == null){
                break;
            }
            length++;
            cur = cur.next;
        }
        return length;
    }

    //查找倒数第k个节点【新浪面试题】
    public static HeroNode findLastIndexNode(int lastIndex, HeroNode head){
        int length = getLength(head);
        if (lastIndex > length || lastIndex < 1){
            throw new RuntimeException("超出范围");
        }
        int index = length - lastIndex + 1;//正数第几个
        HeroNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    //单链表的反转【腾讯面试题】
    public static void reversetList(HeroNode head){
        if (head.next == null || head.next.next == null){
            return;
        }
        HeroNode temp = head.next;
        HeroNode temp2 = null;
        HeroNode next = null;
        HeroNode reverseNode = new HeroNode(0,null,null);
        /*while (true){//自己想法
            if (temp.next == null){
                temp.next = reverseNode.next;
                reverseNode.next = temp;
                head.next = reverseNode.next;
                break;
            }
            temp2 = temp;
            temp = temp.next;
            temp2.next = reverseNode.next;
            reverseNode.next = temp2;
        }*/
        //老师给的方法
        while (temp != null){
            next = temp.next;
            temp.next = reverseNode.next;
            reverseNode.next = temp;
            temp = next;
        }
        head.next = reverseNode.next;
        return;
    }

    //逆序打印单链表【百度面试题】
    public static void reversePrint(HeroNode head){
        if (head.next == null){
            return;
        }
        HeroNode temp = head.next;
        Stack<HeroNode> stack = new Stack<>();
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }

    //合并两个有序链表
    public static void mergeLinkedList(SingleLinkedList singleLinkedList, HeroNode head){
        if (head.next == null) {
            return;
        }
        HeroNode temp = head.next;
        HeroNode next = null;
        while (true) {
            if (temp.next == null) {
                singleLinkedList.addByOrder(temp);
                return;
            }
            next = temp.next;
            singleLinkedList.addByOrder(temp);
            temp = next;
        }
    }
}

class SingleLinkedList{
    HeroNode head = new HeroNode(0,null,null);
    //添加人物
    public void add(HeroNode heroNode){
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }
    //顺序添加人物
    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;

        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no){
                break;
            }
            temp = temp.next;
        }
        heroNode.next = temp.next;
        temp.next = heroNode;
    }
    //改变指定节点信息
    public void update(int no, String newName){
        if (head.next == null){
            System.out.println("链表为空");
        }
        HeroNode temp = head.next;
        while (true){
            if (temp.next == null){
                if (temp.no == no){
                    temp.name = newName;
                }else {
                    System.out.println("没找到");
                }
                break;
            }
            if (temp.no == no){
                temp.name = newName;
                break;
            }
            temp = temp.next;
        }
    }
    //删除指定节点
    public void del(int no){
        if (head.next == null){
            System.out.println("链表为空");
        }
        HeroNode temp = head;
        while (true) {
            if (temp.next == null){
                System.out.println("未找到指定数据");
                break;
            }
            //判断下一个是否一样,一样删除
            if (temp.next.no == no){
                temp.next = temp.next.next;
                break;
            }
            //不一样，下一个
            temp = temp.next;
        }
    }
    //打印全部链表
    public void list(){
        if (head.next == null) {
            System.out.println("链表为空");
        }
        HeroNode temp = head.next;
        while (true) {
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

class HeroNode{
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

双向链表的增删改查操作

package 双向链表;


public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero4);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);

//        doubleLinkedList.del(3);

//        doubleLinkedList.update(new HeroNode(4,"修改","修改"));

        doubleLinkedList.list();


    }
}
class DoubleLinkedList {
    private HeroNode head = new HeroNode(0, null, null);

    public HeroNode getHead() {
        return head;
    }

    //遍历双向链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        while (temp != null){
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //添加节点到最后
    public void add(HeroNode heroNode){
        HeroNode temp = head;
        while (temp.next != null){
            temp = temp.next;
        }
        temp.next = heroNode;
        heroNode.prev = temp;
    }

    //按照编号大小顺序添加
    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        while (temp.next != null){
            if (temp.next.no > heroNode.no){
                heroNode.next = temp.next;
                heroNode.prev = temp;
                temp.next.prev = heroNode;
                temp.next = heroNode;
                return;
            }else if (temp.next.no == heroNode.no){
                System.out.println("已有该编号的节点");
                return;
            }
            temp = temp.next;
        }
//        this.add(heroNode);//感觉效率不高，还是算了
        temp.next = heroNode;
        heroNode.prev = temp;
    }

    //修改节点内容
    public void update(HeroNode newNeroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (temp != null){
            if (temp.no == newNeroNode.no){
                flag = true;
                temp.name = newNeroNode.name;
                temp.nickName = newNeroNode.nickName;
                return;
            }
            temp = temp.next;
        }
        if (flag == false){
            System.out.printf("没找到编号为%d的节点\n",newNeroNode.no);
        }
    }

    //删除节点
    public void del(int no){
        if (head.next == null){
            System.out.println("链表已空");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (temp != null){
            if (temp.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag == false){
            System.out.println("未找到该节点");
        }else {
            temp.prev.next = temp.next;
            if (temp.next != null) temp.next.prev = temp.prev;//最后一个要特殊处理！！不然空指针异常
        }
    }

}
class HeroNode{
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;
    public HeroNode prev;

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}
单链表的删除操作
DevScribe的博客
09-04 788
单链表是一种常见的数据结构，它由一个个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。在单链表中，删除操作是一种常见的操作，它允许我们从链表中删除指定的节点。以上就是用C语言实现单链表删除操作的示例代码。通过这个例子，我们可以清楚地了解如何在单链表中删除指定的节点。在上面的代码中，我们首先定义了一个单链表节点的结构体，其中。函数中，我们首先创建一个空链表，然后使用。函数删除值为3的节点，并最后调用。函数打印删除节点后的链表。用于删除指定值的节点，用于打印链表中的节点。
单链表（C语言，带头节点，增删查改）
weixin_63042414的博客
10-08 537
链表是数据结构中比较重要的一种结构，起初我在学习的时候也糊涂了好久，后来呢，一直独自写了好几遍才渐渐有了感觉。我的经验是必须要深入到内存中去学习，或者说是深刻理解一个链表从创建到销毁的过程中内存的变化。单链表有两种，一种是头结点有数据的，一种是头结点不含数据的，其实两者没有什么大差别，本文演示的是头结点不含数据的单链表。节点在内存中就是我们开辟出的一小块空间，它由两小块组成，一部分是数据域，一部分是指针域。
单链表----增删查改（C语言版）
折木的博客
02-19 1378
前言 链表是数据结构中一种特别重要的结构，它和顺序表同属于线性表的一种。不同于顺序表的是，链表并没有局限于物理内存上的连续性，而是一种在逻辑上连续的线性表，因此链表可以实现很多顺序表难以实现的功能。 形象的理解，链表结构就像现实中链条一样，将一串单个物体串联在一起。 数据结构中的链表是主要这样： 链表分为多种类型，有单向链表、双向链表、带头链表、不带头链表等等…… 虽然链表类型多种多样，但实际中最常用的只有以下两种： 本篇文章我将主要向大家介绍无头单项非循环链表（单链表），这种链表结构简单，一般不会单
3.3 链表 (单链表修改，删除)
weixin_45706249的博客
07-11 678
修改节点 1.先找到该节点，通过遍历 2.temp.name = newHeroNode.name; temp.nickname = newHeroNode.nickname; 代码如下： //修改节点的信息，根据no编号来修改，即no编号不能改 public void update(HeroNode newHeroNode){ if (head.next == null){ System.out.println("链表为空！！"); } boolean flag
链表的修改
ADbyCool的博客
05-19 1783
链表的修改 func.h #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct student{ int num; float score; //新来的学生 struct student *pNext; }stu,*pstu; void list_sort_insert(pstu *,pstu *,int); void list_modify(pstu,i
cpp代码-双向链表的CRUD
07-16
总结起来，C++中的双向链表CRUD操作是数据结构和算法学习的重要组成部分，掌握这些基本操作有助于提升编程能力和解决复杂问题的能力。通过阅读和理解`main.cpp`中的代码，以及遵循`README.txt`的指导，可以深入学习...
Java之链表(不带头结点,带头结点,迭代实现,递归实现)
qq_64580912的博客
03-20 1700
在实现具体的方法之前,我们先定义一个接口,之后的这些链表都将实现这些接口,实现这些接口内的方法,主要包含了一些常用的CRUD方法.这个接口我们使用了泛型,之后的链表类也将继承这个接口的泛型,元素的类型就是泛型的类型// 在线性表中的最后插入值为element的新元素// 在线性表的前边插入新元素，插入后的元素下标为index//在索引为index处插入值为element的结点// 删除当前线性表中索引为index的元素，返回删除的元素值// 删除当前线性表中第一个值为element的元素。
数据结构双向链表插入
08-20
双向链表的插入操作相对于单向链表来说更加方便，因为它可以通过修改前一个节点和后一个节点的指针来实现插入，而无需通过辅助节点进行操作。这也是双向链表相较于单向链表的一个优势之一。<span class="em">1...
JAVA基础--单链表的添加||在火车车厢的头部、中间、尾部添加节点
weixin_48454152的博客
08-21 412
JAVA基础--单链表的添加||在火车车厢的头部、中间、尾部添加节点
循环链表与双向链表详解：基本操作与应用实例
循环链表适用于数据元素有环型结构的情况，插入和删除操作与单向链表类似，但查找时需要特别注意循环性，避免死循环。 - 判断链表为空或满的关键在于理解循环性，即检查当前节点的下一个节点是否等于头节点而非...
C单链表修改
小豹Miss鲍的博客
09-22 1100
//1、在代码里面的头文件，要知道是为了那个函数#include的头文件。---对应起来。 #include <stdio.h> //我是Mac，头文件malloc.h在sys里面。 #include <sys/malloc.h> #include <stdlib.h> struct student *del(struct student *head, int...
单链表的修改和删除
m0_56969616的博客
09-20 1483
文章目录一、单链表的修改1.思路2.代码实现二、单链表的删除1.思路2.代码实现 一、单链表的修改 1.思路 1）先找到该节点，通过遍历,寻找节点通过编号来进行查找 2）找到该节点后，通过辅助变量对其进行修改（temp.name = heronode.name,temp.nickname = heronode.nickname） 2.代码实现 写一个update方法，该方法先遍历查找，后进行修改 //修改节点的信息，根据no编号来修改，即no编号不能改 //1、根据heronode的No来修
链表代码修改
only_one_to_all的博客
06-17 215
尹成老师_链表教学代码修改 我相信不少小伙伴都有看过这位老师的教学吧！ 说实话这老师的课真不错，要是我大学的时候跟他学习，估计可以少走不少弯路。 不废话了，我看了他链表课程的删除和插入，功能都可以实现，但是一旦删除的元素或者插入的元素链表内没有，那么就会报错了。所以我这里做了一些修改，目前测试没发现异常，所以拿出来给大家分型一下。 代码如下： struct LinkNode { int data; struct LinkNode *pnext; }; typedef struct LinkNode node
链表修改数据（附完整代码）
Discod_lim的博客
03-17 1737
链表修改数据（附完整代码）
【小白学算法】6.单链表的修改、删除
weixin_48967543的博客
03-26 588
接着上一章继续来看单链表。 之前对单链表进行了遍历、插入的操作，本章继续用代码来实现修改以及删除。 一、单链表的修改免费优惠券 m.cps3.cn 修改结点信息首先需要先找到对应的结点，接着上一章的代码，也就是英雄的排名no是不能修改的，要用来找结点。 其他的信息就可以动了。 另外，还要考虑到单链表中找不到对应要修改的结点的情况。这里代码就不全贴出来了，现在继续在SingleLinkedList类 中增加修改结点信息的方法： // 修改结点信息 // 根据结点的no来修改即可 pu.
简单链表的删除与修改
orang_e的博客
07-08 426
简单链表的删除与修改 /** * 单向链表 * 链表由一系列节点组成，这些节点不必在内存中相连。 * 每个节点都含有表元素和到包含该元素后继元的节点的链，即next链(next 为链表的对象)。 * 最后一个单元的next链引用null.。 * * @author Rocco_L * */ /* * 链表的修改删除功能 * * 修改节点功能思路： * 1.先找到该节点（通过遍历） * 2.通过辅助变量来修改内容 * * 删除节点功能思路： * 1. 通过辅助节点找到需
【数据结构】单向链表的修改和删除
dengmsjava的博客
05-10 1565
单向链表的修改和删除 从单链表中删除一个节点思路： 1.找到需要删除节点的前一个节点temp； 2.temp.next = temp.next.next 3.被删除的节点，将不会有其他引用指向，会被垃圾处理机制回收
【数据结构】单链表-修改节点和删除节点
JH灰色的博客
03-31 951
文章目录1. 修改节点2. 删除节点 单链表按照节点编号来修改节点和删除节点 1. 修改节点 修改节点的代码： //修改节点信息，根据no编号来修改 public void update(HeroNode newHeroNode){ //判断是否为空 if(head.next==null){ System.out.println("链表为空"); return; ...
单链表中的删除操作
song_10的博客
12-20 4137
题目：设单链表以非递减有序列，设计算法实现在单链表中删除值相同的多余结点 C++是实现如下： #include <iostream> using namespace std; struct Node { int data; Node *next; }; class LinkList { public: LinkList();//初始化空链表 LinkList(int b...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值