单链表无头非循环与双链表无头循环Java实现

已于 2022-04-23 14:10:30 修改
阅读量819 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： java 链表 数据结构
于 2021-11-11 20:30:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenbaifan/article/details/121267443
版权
这篇博客详细介绍了链表数据结构的两种常见实现——无头非循环单链表和无头双向循环链表。内容包括它们的节点定义、头结点处理、插入、删除、查找等基本操作。通过示例代码展示了如何在不同位置插入元素、删除特定关键字的节点以及清空链表等功能。此外，还提供了头插法、尾插法以及任意位置插入的实现方法。
摘要由CSDN通过智能技术生成

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

目录

单链表无头非循环

// 1、无头单向非循环链表实现
public class SingleLinkedList {
//打印链表
 public void display();
     //头插法
     public void addFirst(int data);
     //尾插法
     public void addLast(int data);
     //任意位置插入,第一个数据节点为0号下标
     public boolean addIndex(int index,int data);
     //查找是否包含关键字key是否在单链表当中
     public boolean contains(int key);
     //删除第一次出现关键字为key的节点
     public void remove(int key);
     //删除所有值为key的节点
     public void removeAllKey(int key);
     //得到单链表的长度
     public int size();
    //清空链表
     public void clear();
 }

定义一个节点，一个放值，一个放他指向下一个节点的地址
在这里插入图片描述大致就是这样子的一种链表，一个指一个
在这里插入图片描述

把第一个定义为头结点
在这里插入图片描述

注意，头不能移动，所以我们遍历要重新给头定义一个变量

class ListNode{  //定义一个节点
    public int val; //
    public ListNode next; //指向后一个节点

    public ListNode(int val){  //构造方法
        this.val = val;
    }
}


public class MyLinkedList{

    public ListNode head; //定义一个头结点

    //打印链表
public void display(){
    ListNode cur = this.head; //重新定义一个头结点，让源头节点不动
    while(cur != null){   //遍历链表
        System.out.print(cur.val+" ");  //打印链表
        cur = cur.next; //走向下一个节点
    }
    System.out.println(); // 换行
}

//获得链表长度
public int size(){
    ListNode cur = this.head;
    int count = 0;  //定义一个计数量
    while(cur != null){
        count++; //遍历一个加一个
        cur = cur.next;
    }
    return count; //返回遍历的长度
}

//判断链表中是否含有关键字key
    public boolean contains(int key){
    ListNode cur = this.head;
    while(cur != null){
        if(cur.val == key){  //如果等于要找的关键字
            return true; //返回正确
        }
        cur = cur.next;
    }
    return false;  //遍历完都没有找到，返回false
    }

    //头插法
    public void addFirst(int data){
    ListNode node = new ListNode(data);  //定义要插的节点
    node.next = this.head;  //要插的节点的下一个节点地址先指向头
    this.head = node;       //要插节点变成新头
    }

    //尾插法
    public void addLast(int data){

    ListNode node = new ListNode(data);
    if(this.head == null){   //头结点为空
        this.head = node;    //直接变成头插进去
    }else{
        ListNode cur = this.head;
        while(cur.next != null){   //遍历到最后一个节点，因为最后一个节点的下一个指向是空
            cur = cur.next;
        }
        cur.next = node; //最后节点下一个指向变成node,让node变成最后一个节点
    }
    }

    /**
     * 找到增加元素的前一个节点
     * @param index
     * @return
     */
    public ListNode findIndex(int index){
    ListNode cur = this.head;
    while(index - 1 != 0){  //找到要增加位置前一个节点
        cur = cur.next;
        index--;
    }
    return cur;      //返回找到的节点
    }

    //在任意位置增加元素，初始元素为0下标
    public void addIndex(int index,int data){
        if(index < 0 || index > size()){  
            System.out.println("index 位置不合法！");
            return;
        }
        if(index == 0){  //头插法
addFirst(data);
return;
        }
        if(index == size()){  //尾插法
            addLast(data);
            return;
        }
        ListNode cur = findIndex(index);  //找到的节点
    ListNode node = new ListNode(data);   //要插的节点
node.next = cur.next;    //前一个节点下一个地址给现在插进去的节点的下一个地址
cur.next = node;        //让前一个节点下一个地址变为现在插的节点地址
    }

    /**
     * 找到要删除关键字的前驱
     * @param key
     * @return
     */
    public ListNode search(int key){
        ListNode cur = this.head;
        while(cur.next != null){    
            if(cur.next.val == key){   //cur的下一个节点的值跟要删的一样
                return cur;    //返回cur
            }
            cur = cur.next;
        }
        return null;  //没有要删的关键字
    }

    //删除第一次出现的关键字key
    public void remove(int key){
        if(this.head == null){
            System.out.println("单链表为空，不能删除！");
            return;
        }
        if(this.head.val == key){  //头结点是要删的
            this.head = this.head.next;  //头结点变为下一个
            return;
        }
        ListNode cur = search(key);
        if(cur == null){  //没找到
            System.out.println("没有你要删的数！");
            return;
        }
            ListNode del = cur.next;  //要删的节点
            cur.next = del.next;    //让要删的前一个节点指向要删的后一个节点，这要要删的节点就没人引用，就删除了，被jvm回收
    }

    //删除所有关键字key
    public ListNode removeAllKey(int key){
        if(this.head == null){
            return null;
        }
        ListNode prev = this.head;  //定义头结点
        ListNode cur = this.head.next;  //定义头结点的下一个节点
        while(cur != null){ //遍历
            if(cur.val == key){  //找到要删的key
                prev.next = cur.next; //直接让前一个节点指向后一个节点
                cur = cur.next; //cur跳到后一个节点
            }else{
                prev = cur;  //前一个不删，prev跳过去
                cur = cur.next; //cur跟着跳
            }
        }
        if(this.head.val == key){   //特殊情况，头结点是要删的，特殊处理
            this.head = this.head.next;
        }
        return this.head;
    }

    //清空链表
    public void clear(){
        while(this.head != null){
            ListNode curNext = this.head.next;  
            this.head.next = null;
            this.head = curNext;
        }
    }
}

双链表无头循环

跟单链表差不多

// 2、无头双向链表实现
public class DoubleLinkedList {
     //头插法
     public void addFirst(int data);
     //尾插法
     public void addLast(int data);
     //任意位置插入,第一个数据节点为0号下标
     public boolean addIndex(int index,int data);
     //查找是否包含关键字key是否在单链表当中
     public boolean contains(int key);
     //删除第一次出现关键字为key的节点
     public void remove(int key);
     //删除所有值为key的节点
     public void removeAllKey(int key);
     //得到单链表的长度
     public int size();
     public void display();
     public void clear();
 }

在这里插入图片描述

class ListNode{  //定义一个节点
    public int val; //
    public ListNode prev; //指向前一个节点  
    public ListNode next; //指向后一个节点

    public ListNode(int val){  //构造方法
        this.val = val;
    }
}


public class MyDoubleLinkedList {

    public ListNode head;
    public ListNode last;  //定义尾结点

    //打印链表
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

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

    //判断链表中是否含有key
    public boolean contains(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);   
        if (this.head == null) { //防止prev为空，造成空指针异常
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

    //找到要插的位置上的节点
    public ListNode findIndex(int index) {
        ListNode cur = this.head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    //任意位置插入key，第一个数据节点为0下标
    public void addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            System.out.println("index 位置不合法！");
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = findIndex(index);
        ListNode node = new ListNode(data);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }

    //删除第一次出现的key
    public void remove(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == this.head) {
                    this.head = this.head.next;
                }
                if (this.head != null) {
                    this.head.prev = null;
                } else {
                    this.last = null;
                }
            } else {
                cur.prev.next = cur.next;
                if (cur.next != null) {
                
                    cur.next.prev = cur.prev;
                } else {
                    this.last = this.last.prev;
                }
            }
            return;
        }
        cur = cur.next;
    }

    //删除所有出现的key
    public void removeAllKey(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    head = head.next;
                    if (head != null) {
                        head.prev = null;
                    } else {
                        last = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        //中间位置
                        cur.next.prev = cur.prev;
                    } else {
                        last = last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

    //清空链表
    public void clear (){
        while(this.head != null){
            ListNode curNext = head.next;
            head.next = null;
            head.prev = null;
            head = curNext;
        }
        last = null;
    }
}

自用！！！

粉色的志明
关注
专栏目录
Java实现顺序表和链表（单链表、双链表）
weixin_50922984的博客
03-22 1375
简单介绍顺序表和链表 并用Java实现顺序表和链表（单链表、双链表）的一些操作 如头插法 尾插法等
数据结构：链表（单向无头非循环）
余音的博客
11-05 557
1 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表的结构 链表就是一个个的节点组成的，一个节点分为两部分（val和next），val用来保存数据，叫做数据域，而next用来保存下一个节点的地址，节点与节点之间连接就是靠next。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、双向 带头、不带头 循环、非循环 而我将描叙的是单向无头非循环链表和双向无头非循环链表，这篇文章先讲单向无头非循环链表.
Java无头单向链表
qq_45349785的博客
09-28 157
链表： 是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、双向 带头、不带头 循环、非循环 对这六种排列组合即可得到八种链表的名称； 我们今天实现的是 无头单向链表 ```java // 1、无头单向非循环链表实现 public class SingleLinkedList { ...
双向非循环链表(没有头结点)
funny_fly的博客
12-12 747
双向非循环链表：虽然没有设置表头，其实是把第一个结点当做表头来处理的。分别实现了：初始化链表、创建链表、从尾部插入链表、获取指定位置结点的值、从头开始遍历链表、给定结点指针分别向前和向后遍历、删除给定位置结点
Java实现无头单向非循环链表
weixin_46660141的博客
07-28 145
创建空的成员变量并用构造函数初始化 class Node { public int data; public Node next; public Node(int data) { this.data = data; } } 遍历链表 public class MyLinkLest { public Node head;//标识头节点 //遍历链表 public void display() { Node c.
链表之无头双向非循环链表（Java语言）
qq_57563254的博客
12-06 1045
无头双向链表（Java语言）前言介绍无头双向非循环链表节点类——ListNode链表类——MyLinkedList打印链表得到链表的长度查找是否包含关键字key插入一个元素——头插法插入一个元素——尾插法插入一个元素——任意位置插入寻找index位置的节点删除第一次出现key的节点删除所有key的节点清空链表总代码 前言 经过对于顺序表和单链表的熟悉我们已经对于数据结构有了简单的认识，这次我们了解无头双向链表的相关知识。 介绍 首先我们先看一下双向链表的结构： 这就是一个非常简单的双向链表，一个节点可以找
C语言~无头链表，双向链表，双向循环链表
小杨的博客
01-26 1001
目录 无头链表： 双向链表： 双向循环链表： 无头链表： 头插： #include <stdio.h> #include <string.h> #include <stdlib.h> //使用二级指针方法 //无头链表：第一个节点存放数据 struct Node { int data; struct Node* next; }; //创建节点 struct Node* createNode(int data) { struct Node.
细说 单链表、双向链表 、LinkedList类（附 add 源码解读）和 ArrayList 和 LinkedList 的区别 —— 数据结构
honglan297的博客
07-25 734
本篇文章将从链表的相关概念入手，对单向、双线链表进行模拟实现，再回到 LinkedList 集合内当中进行简单分析，最后结合上一篇文章，阐述四点 LinkedList 和 ArrayLIst 区别。
图解链表 —— JAVA中的单链表基本操作
AlinaQ05的博客
05-17 2175
文章目录1. 什么是链表2. 链表的种类3. 创建单链表3.1 创建 Node 类（车厢类）3.2 创建 MySingleList (火车类）4. 单链表的基本操作4.1 增加链表元素4.1.1 在链表头部添加元素4.1.2 在链表任意位置添加元素4.1.3 在链表尾部添加元素4.2 删除链表元素4.2.1 删除第一个节点元素4.2.2 删除任意位置 index 元素4.2.3 删除链表中指定元素的第一个节点4.2.4 删除链表的所有指定元素4.3 查找链表元素4.3.1 判断链表中是否包含元素 data4
数据结构之双向链表详解
最新发布
小源_ 的博客
12-20 3564
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
[数据结构]无头循环单链表将P节点的前驱变为P的后继节点
负负得正的博客
11-19 2213
问题描述 假设循环单链表不空, 且无表头节点无表头指针, 指针P指向链表中某节点。请设计一个算法，将P所指向节点的前驱变为P所指节点的后继节点。 Solution 此问题也可以看作交换p与p的后继节点位置 找到三个指针即可 p pp：p的前驱 ppp：p的前驱的前驱 void exchangeNode(Node p) { // 如果只有一个或者两个节点直接退出 if (p->next->next == head) { return; } Node ppp = p, pp =
数据结构二（顺序表 & 链表;循环及无头循环链表 & 链栈 ）
yuanchunsi的博客
07-12 657
本篇博客主要介绍顺序表，队列，链表和链栈的使用！！！(顺序表 & 链表;循环链表;无头循环链表 & 链栈 & joseph函数)
Java实现无头单链表
m0_74304755的博客
11-17 306
Java实现无头单链表的基本方法
Java 无头双向循环链表操作方法
unstoppable_t的博客
01-09 221
class ListNode{ private int val; private ListNode next; private ListNode prev; //结点创建方法 public ListNode(int val) { this.val = val; } public int getVal() { return val; } public void setVal(int val) {
数据结构之无头单向非循环链表
Python_programer的博客
04-05 249
链表在数据结构中相当的重要，在以后的实际工作中使用率也很高，所以今天分享一些关于链表的基本操作： 1.链表的概念以及定义： 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，形式如下图所示： typedef struct Node //链表的定义 { int value; //结点的数据域 str...
数据结构——链表（无头单向非循环链表+ 带头双向循环链表）
weixin_45141313的博客
01-15 208
之前学习链表一头雾水，这讲的什么，黑人问号。现在重新学完链表，不错不错，有意思。这篇文章主要来说两种链表，一是无头+单向+非循环链表增删查改，二是带头+双向+循环链表增删查。 1.链表概念及结构 链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 2.链表的实现 2.1无头单向非循环链表 typedef int LDataType; //定义结点 typedef struct ListNode { LDataType data; struct Li
【数据结构】无头单向非循环链表
卑微楽的开发之路
09-28 140
链表 首先我们来思考一个问题: 为什么要有链表这种结构呢? 上次我们写了顺序表, 其实本质上也就是一个数组, 它已经可以完成数据的存储和访问了, 但是它还存在一些不可避免的问题 1. 顺序表的中间和头部的插入删除的时间复杂度都是O(n), 复杂度太高 2. 增容的时候需要申请新的空间, 还要完成数据从旧空间到新空间的数据拷贝过程, 再释放旧空间, 消耗非常大 3. ...
java语言实现单链表---不含头结点
初心不忘、始终方得
04-19 2277
该篇文章总结使用java语言实现不含头结点的单链表的实现。
链表详解（一）—— 无头单向非循环链表
2021dragon的博客
04-08 2930
文章目录链表介绍初始化链表打印单链表增加数据单链表的头插单链表的尾插删除数据单链表的头删单链表的尾删 链表介绍 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 实际中，链表的结构多种多样： 1、带头，不带头。 2、单向，双向。 3、循环，非循环。 通过以上的这些情况组合起来，就有八种
链表数据结构详解：单链表、循环链表与双向链表
循环链表与单链表的主要区别在于最后一个节点的指针不是空的，而是指向了链表的第一个节点，形成一个闭合的循环。这种结构使得遍历链表更加方便，因为从任一节点开始都可以继续遍历整个链表。循环链表的搜索、插入...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

粉色的志明

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

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

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

打赏作者

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

抵扣说明：

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

余额充值