Java实现单向链表与双向链表简单的增删查操作

最新推荐文章于 2023-05-11 12:58:29 发布
最新推荐文章于 2023-05-11 12:58:29 发布
阅读量216 收藏
点赞数
分类专栏： Java 初学者 文章标签： 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XSAAA/article/details/115143304
版权

目录

链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。


就拿带头单向非循环链表来讲。
val就是数值，可以随便给。
next连接下一个地址，这样就可以串联起来了。
地址可以是无序的，不像顺序表一样它的地址必须是有序的。

单向链表

在这里插入图片描述

创建节点类

class ListNode{
    public int val;
    public ListNode next;

	//构造方法只需要传val值就可以了。
    public ListNode(int val) {
        this.val = val;
    }
}

定义头节点

public ListNode head;

插入

头插法

public void headInsert(int val) {
        //首先new一个节点
        ListNode node = new ListNode(val);
        //判断链表是否为空
        if(empty()) {
            this.head = node;
        } else {
            node.next = this.head;
            this.head = node;
        }
    }

在这里插入图片描述



尾插法

尾插法：如果链表为空就让头节点指向这个new出来的节点，如果链表不为空，定义一个cur，在cur.next不为空的情况下，让cur = cur.next，走到最后一个节点，让最后一节点的next指向node。

public void tailInsert(int val) {
        ListNode node = new ListNode(val);
        if(empty()) {
            this.head = node;
        } else {
            ListNode cur = this.head;
            while(cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

任意位置插入

public void insert(int val,int n) {
        ListNode node = new ListNode(val);
        if(empty()) {
            this.head = node;
        }
        if(n == 0) {
            //使用头插法
            headInsert(val);
            return;
        }
        if(n == size()) {
            //使用尾插法
            tailInsert(val);
            return;
        }
        ListNode cur = this.head;
        int count = 1; //计数，与n相等时插入,默认下标从1开始
        while(n - 1 != count) {
            count++;
            cur = cur.next;
        }
        node.next = cur.next;
        cur.next = node;
    }

查找n位置节点

public ListNode findN(int n) {
        if(this.head == null) return null;
        if(n < 0 || n > size()) return null;
        ListNode cur = this.head;
        int count = 0;
        while(cur != null) {
            count++;
            if(count == n) return cur;
            cur = cur.next;
        }
        return null;
    }

删除节点

public void delVal (int val) {
        //判空
        if(empty()) return;
        if(this.head.val == val) {
            this.head = this.head.next;
            return;
        }
        ListNode prev = this.head;
        ListNode cur = prev.next;
        while(cur != null) {
            if(cur.val == val) {
                prev.next = cur.next;
            } else {
                prev = cur;
            }
            cur = cur.next;
        }
    }

其它方法

判空

public boolean empty() {
        return this.head == null;
    }

计算链表长度

public int size() {
        int count = 0;
        ListNode cur = this.head;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

打印链表

public void display() {
        ListNode cur = this.head;
        while(cur != null) {
            System.out.println(cur.val);
            cur = cur.next;
        }
    }

完整代码

class ListNode{
    public int val;
    public ListNode next;

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

    //判断是否为空
    public boolean empty() {
        return this.head == null;
    }

    //计算链表长度
    public int size() {
        int count = 0;
        ListNode cur = this.head;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    //打印链表
    public void display() {
        ListNode cur = this.head;
        while(cur != null) {
            System.out.println(cur.val);
            cur = cur.next;
        }
    }
    //头插法
    public void headInsert(int val) {
        //首先new一个节点
        ListNode node = new ListNode(val);
        //判断链表是否为空
        if(empty()) {
            this.head = node;
        } else {
            node.next = this.head;
            this.head = node;
        }
    }

    //尾插法
    public void tailInsert(int val) {
        ListNode node = new ListNode(val);
        if(empty()) {
            this.head = node;
        } else {
            ListNode cur = this.head;
            while(cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    //任意位置插入
    public void insert(int val,int n) {
        ListNode node = new ListNode(val);
        if(empty()) {
            this.head = node;
        }
        if(n == 0) {
            //使用头插法
            headInsert(val);
            return;
        }
        if(n == size()) {
            //使用尾插法
            tailInsert(val);
            return;
        }
        ListNode cur = this.head;
        int count = 1; //计数，与n相等时插入,默认下标从1开始
        while(n - 1 != count) {
            count++;
            cur = cur.next;
        }
        node.next = cur.next;
        cur.next = node;
    }

    //查找n位置的节点
    public ListNode findN(int n) {
        if(this.head == null) return null;
        if(n < 0 || n > size()) return null;
        ListNode cur = this.head;
        int count = 0;
        while(cur != null) {
            count++;
            if(count == n) return cur;
            cur = cur.next;
        }
        return null;
    }

    //删除节点
    public void delVal (int val) {
        //判空
        if(empty()) return;
        if(this.head.val == val) {
            this.head = this.head.next;
            return;
        }
        ListNode prev = this.head;
        ListNode cur = prev.next;
        while(cur != null) {
            if(cur.val == val) {
                prev.next = cur.next;
            } else {
                prev = cur;
            }
            cur = cur.next;
        }
    }
    public static void main(String[] args) {
        LinkedList myList = new LinkedList();
        myList.headInsert(2);
        myList.headInsert(1);
        myList.tailInsert(3);
        myList.insert(0,0);
        myList.insert(5,3);
        System.out.println(myList.size());
        System.out.println(myList.findN(3).val);
        myList.delVal(0);

        myList.display();
    }
}

在这里插入图片描述

双向链表

如果掌握了单向链表，那么双向链表会更加的简单。
注意：增加或者删除一个节点，那么它的next与prev都要改动。
在这里插入图片描述

创建类

class ListDNode{
    public int val;
    public ListDNode next; //后继
    public ListDNode prev;//前驱

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

头节点与尾节点

	public ListDNode head;
    public ListDNode last;

头插法

	public void headInsert(int val) {
        ListDNode node  = new ListDNode(val);
        if(isEmpty()) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

尾插法

    public void tailInsert(int val) {
        ListDNode node = new ListDNode(val);
        if(isEmpty()) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

任意位置插入

	public void insert(int val,int n) {
        if(n > size() || n < 0) return;
        if(n == 0) {
            headInsert(val);
            return;
        }
        if(n == size()) {
            tailInsert(val);
            return;
        }
        ListDNode node = new ListDNode(val);
        ListDNode cur = this.head;
        while(n  != 0) {
            cur = cur.next;
            n--;
        }
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }

删除出现的值

	public void delAll(int val) {
        ListDNode cur = this.head;
        while(cur != null) {
            if(cur.val == val) {
                if(cur.val == this.head.val) {
                    this.head = this.head.next;
                    this.head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if(cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.last = this.last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

完整代码及运行结果

class ListDNode{
    public int val;
    public ListDNode next;
    public ListDNode prev;

    public ListDNode(int val) {
        this.val = val;
    }
}
public class DoubleLinkedList {
    public ListDNode head;
    public ListDNode last;

    public boolean isEmpty() {
        return this.head == null;
    }
    public void display() {
        ListDNode cur = this.head;
        while(cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }
    public int size() {
        ListDNode cur = this.head;
        int count = 0;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
    //头插法
    public void headInsert(int val) {
        ListDNode node  = new ListDNode(val);
        if(isEmpty()) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

    //尾插法
    public void tailInsert(int val) {
        ListDNode node = new ListDNode(val);
        if(isEmpty()) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

    //任意位置插入
    public void insert(int val,int n) {
        if(n > size() || n < 0) return;
        if(n == 0) {
            headInsert(val);
            return;
        }
        if(n == size()) {
            tailInsert(val);
            return;
        }
        ListDNode node = new ListDNode(val);
        ListDNode cur = this.head;
        while(n  != 0) {
            cur = cur.next;
            n--;
        }
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }

    //删除出现一次的值
    public void deleteNode(int val) {
        if(isEmpty()) return;
        if(this.head.val == val) {
            this.head = this.head.next;
            this.head.prev = null;
            return;
        }
        if(this.last.val == val) {
            this.last.prev.next = null;
            this.last = this.last.prev;
            return;
        }
        ListDNode cur = this.head;
        while(cur != null) {
            if(cur.val == val) {
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
                return;
            }
            cur = cur.next;
        }
    }

    //删除所有出现的值
    public void delAll(int val) {
        ListDNode cur = this.head;
        while(cur != null) {
            if(cur.val == val) {
                if(cur.val == this.head.val) {
                    this.head = this.head.next;
                    this.head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if(cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.last = this.last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }
    public static void main(String[] args) {
        DoubleLinkedList myList = new DoubleLinkedList();
        myList.headInsert(1);
        myList.headInsert(2);
        myList.tailInsert(3);
        myList.tailInsert(5);
        myList.insert(4,4);
        myList.insert(22,3);
        myList.insert(11,1);
        myList.delAll(11);
        myList.display();
    }
}

在这里插入图片描述

一位懒得写博客的小学生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java数据结构与算法】双向链表
12-21
单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面删除单向链表节点时，需要找到temp的下一个节点来删除 如若未了解单链表请参考–>单链表点这里 双向链表示意图如下： 分析双向链表的...
单链表头插法函数LinkList List_HeadInsert(LinkList &L)中&L详解
weixin_43624310的博客
08-16 1554
因为地址的变化会导致free的时机难以把握，本文有助于读者掌握free时机
C++ 头结点单链表——头插法尾插法及改写为类模板封装函数代码
qq_62015542的博客
05-11 900
本文章是对面向对象中单链表的头插法尾插法及类模板封装的总结，仅供参考
链表插入的三种方式
热门推荐
致终将努力的我们
08-30 1万+
链表的插入： 一、头插 1、判断空链 ： a：新节点指向NULL b: 头指向新节点 2、非空链 a: 新节点指向头（第一个节点） b: 头指向new 综上： 不需判断直接在头操作 代码： void insert_head(Node * head , Node new) { new = * head; * head = new;
头插法建立单链表——借鉴博客园小久（考研）
xkcodeblocks的博客
04-01 1204
概念描述 单链表是一种链式存储的数据结构，每一个节点存放数据和指向下一个节点的指针。 头插法是指每次将新节点插入头部（head节点之后），最终链表顺序与插入顺序相反。 这就好比你在食堂排队，大妈所在窗口是头部，每次都有人插入到队伍最前面，结果你是最后买到饭的。 #include<stdio.h> #include<stdlib.h> typedef stru...
头插法建立链表
代码大湿的专栏
04-20 1148
介绍下头插法建立链表C++实现。 说明：头插法建立的链表元素顺序是和输入的顺序相反的，如果要顺序保持一致，建议用尾插法。
java 单链表和双向链表的实现
08-06
操作包括： 1. 在头部添加结点 2. 在尾部添加结点 3. 遍历 4. 逆置 5. 删除
java实现的单向链表和双向链表
09-28
里面有注释，很详细。 对于数据结构基础不是很好地朋友来说，有很大的帮助。
简单介绍线性表以及如何实现双链表
09-03
本文先介绍线性表的几个基本组成部分：数组、单向链表、双向链表；随后给出双向链表的C、C++和Java三种语言的实现,需要的朋友可以参考下
LinkedList:该项目提供了单向、双向和循环链表的示例
07-02
链表该项目提供了单向、双向和循环链表的示例
单链表（带头结点）的基本操作
H643511的博客
09-27 6155
带头结点的单链表的基本操作基本概念单链表的定义初始化单链表单链表表长头插法建立单链表的操作尾插法建立单链表的操作按元素查找按位置查找单链表插入数据删除数据判空操作输出清空表 基本概念 线性表的链式存储又称单链表，它是通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。 单链表的定义 定义该结点的数据和后继的指针的地址 typedef struct LNode { LNode* next; ElemType
单链表的创建、查找、插入与删除
fakerth的博客
06-02 4261
单链表：
Java单链表头插法和尾插法以及增删改查方法
weixin_38568503的博客
01-17 1887
一、单链表的头插法： 头插法原理图： 代码演示头插法： package com.fan.linkedlist; public class SingleLInkedListDemo3 { public static void main(String[] args) { SingleLInkedList3 singlelist3 = new SingleLInkedList3(); System.out.println(singlelist3.headInsert(1)
c语言insertHead函数怎么用,(C语言)写一个函数insert,用来向一个动态链表插入节点...
weixin_39777488的博客
05-20 616
写一个函数insert,用来向一个动态链表插入节点用creat,print,del,insert四个函数,编写主函数,先后调用这些函数,实现链表的建立,输出,删除和插入,从主函数中指定需要删除和插入的节点的数据 https://blog..net/qq_41071068/article/details/90117026#define _CRT_SECURE_NO_WARNINGS#include#...
数据结构学习--头插法建立链表&&如何从开始建立链表L
weixin_44644713的博客
02-07 183
From Start 从头开始建立链表李春葆数据结构代码学习新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 李春葆数据结构代码学习 在学习过程中发现书上写了大概的实现步骤 咱们来具体实现它 新的改变 我们对Markdow
简单实现双向链表的初始化 插入 搜索 删除元素
简单记录些知识
01-26 1086
在这里实现下双向链表，感觉比单向的简单，以后都这样写好了。 题目大概是这样的： 首先输入命令总数n，然后输入命令和数字， 命令有这些： insert x：在链表开头添加含有键值x的结点（也就是head与下一个结点之间） delete x：删除第一个含有键值x的结点 deleteFirst：删除链表的表头结点 deleteLast：删除链表的表尾结点 所有命令执行完后，顺次输出链表的...
【数据结构与算法】单向链表与双向链表的增删改查（包括有序插入到链表）
像风走过八千里
04-11 516
单向链表 1、链表是以节点的方式来存储，是链式存储 2、每个节点包含data域，next域：指向下一个节点 3、链表的每个节点不一定是连续存储 4、链表分带头节点的链表和没有头节点链表，根据需求确定 1、遍历 通过一个辅助遍历，帮助遍历整个链表 2、添加（创建） （1）先创建一个head头节点，作用就是表示单链表的头 （2）后面每添加一个节点，就直接加入到链表的最后 添加有俩种形式，一种是直接...
单向链表和双向链表区别_数据结构双向链表的增加删除操作
weixin_39557402的博客
12-06 419
好久不见大家，由于上周学校教学安排原因，公众号停更了一段时间，让大家久等了，今天我要和大家分享的是数据结构中链表的另一种表现形式——双向链表。十几天前，我和大家分享了数据结构中的单向链表的增删改查知识，今天要介绍的双向链表的知识和单向链表的知识大同小异，双向链表就相当于单向链表的延伸，没有看过单向链表的童鞋可以看一下前几期单向链表的文章，双向链表的知识相对于掌握了单向链表知识的同学更容易...
找出链表的第一个公共结点 java_结构与算法(03)：单向链表和双向链表
weixin_39768444的博客
11-21 165
一、链表简介1、链表概念链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成，节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。2、基础特点内存存储逻辑结构特点描述物理存储上是无序且不连续的；链表是由多个节点以链式结构组成；逻辑层面上看形成一个有序的链路结构；链表结构解决...
Java中的LinkedList是单项链表还是双向链表
最新发布
06-11
Java中的LinkedList是双向链表。除了包含指向下一个节点的指针外，每个节点还包含一个指向前一个节点的指针。这个特性使得LinkedList在插入和删除元素时比单向链表更加高效，因为在双向链表中，可以通过前驱节点直接访问后继节点，而不必遍历整个链表来查找后继节点。但是，双向链表也会消耗更多的内存，因为每个节点需要多一个指向前驱节点的指针。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值