Sequential And Linked Lists - 顺序表 和 链表 - 双向链表部分 - java

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量440 收藏 13
点赞数 5
分类专栏： 作者\/ 文章标签： java 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85111798/article/details/139273931
版权 
        cur= cur.next;// cur 代替 head 遍历链表

    }

}




* * *



### [](https://docs.qq.com/doc/DSmxTbFJ1cmN1R2dB)clear - 清空 链表节点




public void clear() {

    while(this.head!=null){// 将链表中，每个元素置为null

        ListNode headNext = this.head.next;

        this.head.prev =null;

        this.head.next = null;

        this.head = headNext;// head 在此过程中，置为null，因为 最后一个元素的next 等null，

    }

    this.last = null;// last 最后 也置为null

}

}




* * *



[](https://docs.qq.com/doc/DSmxTbFJ1cmN1R2dB)直至双向链表的所有功能就都实现了，随后附上整体程序（附赠带头的双向链表）

===================================================================================================



> 至于如何测试功能，直接新建一个类，在main方法中，new一个 DoubleLinkedList 对象，通过对象的引用，去调用 双向链表的功能。参数自己决定。

class ListNode {

public int val;

public ListNode prev;

public ListNode next;



public ListNode(int val) {

    this.val = val;

}

}

public class DoubleLinkedList {

public ListNode head = new ListNode(-1);//指向双向链表的头节点

public ListNode last;//指向的是尾巴节点



// 带头

public void display() {

//和单链表的打印方式是一样

    if(this.head.next==null){

        return;

    }

    ListNode head1 = this.head.next;

    ListNode cur = head1;

    while (cur != null) {

        System.out.print(cur.val +" ");

        cur = cur.next;

    }

    System.out.println();

}



// 不带头

// public void display() {

和单链表的打印方式是一样

// ListNode cur = this.head;

// while (cur != null) {

// System.out.print(cur.val +" ");

// cur = cur.next;

// }

// System.out.println();

// }

//得到单链表的长度

// 带头的

public int size() {

    if(this.head.next==null){

        return 0;

    }

    int count = 0;

    ListNode cur = this.head.next;

    while (cur != null) {

        count++;

        cur = cur.next;

    }

    return count;

}

// 不带头

// public int size() {

// int count = 0;

// ListNode cur = this.head;

// while (cur != null) {

// count++;

// cur = cur.next;

// }

// return count;

// }

//查找是否包含关键字key是否在单链表当中

// 带头的

public boolean contains(int key) {

    if(this.head.next==null){

        return false;

    }

    ListNode cur = this.head.next;

    while (cur != null) {

        if (cur.val == key) {

            return true;

        }

        cur = cur.next;

    }

    return false;

}

// 不带头的

// 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.next == null){

        this.head.next = node;

        node.prev = head;

        this.last = node;

    }else{

        node.next = this.head.next;

        node.prev = this.head;

        this.head.next = node;

    }

}



// 不带带头的

// public void addFirst(int data) {

// ListNode node = new ListNode(data);

// if (this.head == null) {

// 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.next == null){

        this.head.next = node;

        node.prev = head;

        this.last = node;

        return;

    }

    this.last.next = node;

    node.prev = this.last;

    this.last = node;

}



// 不带头的：

// public void addLast(int data) {

// ListNode node = new ListNode(data);

// if (this.head == null) {

// this.head = node;

// this.last = node;

// return;

// }

// last.next = node;

// node.prev = last;

// last = node;

// }

//任意位置插入,第一个数据节点为0号下标

// 带头的

public void addIndex(int index, int data) {

    if(index<0||index>size()){

        System.out.println("index 位置不合法");

        return ;

    }

    ListNode node = new ListNode(data);

    if(index == 0){

        addFirst(data);

        return ;

    }

    if (index == size()){

        addLast(data);

        return ;

    }

    ListNode cur = searchIndex(index);

    node.next = cur;

    node.prev = cur.prev;

    cur.prev.next =node;

    cur.prev = node;

}

public  ListNode searchIndex(int index){

    ListNode cur = this.head.next;

    while(index!=0){

        cur = cur.next;

        index--;

    }

    return cur;

}



// 不带头的

// public void addIndex(int index, int data) {

// if(index<0||index>size()){

// System.out.println(“index 位置不合法”);

// return ;

// }

// ListNode node = new ListNode(data);

// if(index == 0){

// addFirst(data);

// return ;

// }

// if (index == size()){

// addLast(data);

// return ;

// }

// ListNode cur = searchIndex(index);

// node.next = cur;

// node.prev = cur.prev;

// cur.prev.next =node;

// cur.prev = node;

// }

// public ListNode searchIndex(int index){

// ListNode cur = this.head;

// while(index!=0){

// cur = cur.next;

// index–;

// }

// return cur;

// }

//删除第一次出现关键字为key的节点

// 带头的

public void remove(int key) {

    if (this.head.next == null) {

        return;

    }

    ListNode head1 = this.head.next;

    ListNode cur = head1;

    while (cur != null) {

        if (cur.val == key) {

            if (head1 == cur) {

                if (cur.next == null) {

                    this.head.next = null;

                    this.last = this.head;

                }else {

                    cur.prev.next = cur.next;

                    cur.next.prev = cur.prev;

                }

            } 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;

    }

}



// 不带头的

// public void remove(int key) {

// if(this.head==null){

// return;

// }

// ListNode cur = this.head;

// while(cur!=null){

// if(cur.val==key){

// if(this.head == cur){

// 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) {

    if (this.head.next == null) {

        return;

    }

    ListNode head1 = this.head.next;

    ListNode cur = head1;

    while (cur != null) {

        if (cur.val == key) {

            if (head1 == cur) {

                if (cur.next == null) {

                    this.head.next = null;

                    this.last = this.head;

                }else {

                    cur.prev.next = cur.next;

                    cur.next.prev = cur.prev;

                }

            } 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 void removeAllKey(int key) {

// if(this.head==null){

// return;

// }

// ListNode cur = this.head;

// while(cur!=null){

// if(cur.val==key){

// if(this.head == cur){

// 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;

// }

// }

// 不带头

// public void clear() {

// while(this.head!=null){

// ListNode headNext = this.head.next;

// this.head.prev =null;

// this.head.next = null;

// this.head = headNext;

// }

// this.last = null;

// }

//

//}

// 带头

public void clear() {

    if(this.head.next == null){

        this.last = null;

        this.head = null;

        return;

    }else {

        while(this.head.next!=null){

            ListNode headNext = this.head.next;

            this.head.prev =null;

            this.head.next = null;

            this.head = headNext;

        }

        this.last = null;

    }

}

}

2401_85111798
关注
专栏目录
Python数据结构与算法（2.6）——块状链表
盼小辉丶的博客
01-31 1万+
块状链表 (Unrolled Linked Lists) 是单链表的变体，其降低了访问单链表中指定位置元素的时间复杂度，块状链表中的每个块结点(简称块)中存储了多个数据元素结点，每个块中的结点使用一个循环链表进行连接。本节讲介绍块状链表的基本概念并实现其基本操作。
线性表Part1--定义及ADT、顺序、链式存储结构及其部分操作具体实现（C语言描述）
ZZay's
06-25 2399
线性表Part1–定义、抽象数据类型(ADT)、顺序存储结构定义及其部分操作具体实现方法（C语言描述） 此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 1.线性表(List)的定义: 线性表(List)：零个或多个数据元素的有限序列。 通常将线性表记作(a1,a2,…,an)，n指表长，当n=0时称该表为空表。同时注意此处下标是从1开始的。 线性表包括顺序表和链表。二者的主要区别在于： 在顺序表中，数据元素是用一段地址连续的存储
Sequential And Linked Lists - 顺序表 和 链表 - 顺序表部分 - java
2401_87251447的博客
09-22 448
顺序表和链表 是 数组 与 类和对象 的一种整合。顺序表和链表 是 数据结构的基础。非常重要。线性表顺序表（一个面向对象的数组）概念及结构&ensp；顺序表讲解图。
Sequential And Linked Lists - 顺序表 和 链表 - 单向链表部分 - java（图文并茂，你值得一看）
2401_84098033的博客
05-03 594
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！遍历链表数据=====================================================================首先，我要区分清楚，链表 不是顺序表，不是一块连续的空间。 链表的每个元素 是由地址来连接起来的。也就是说 我们不能使用普通思维模式 去思考 遍历链表的数据域的值既然 链表是靠地址联系起来的，也就是说 靠 next域中 存储的地址来联系个节点的数据这就是我们突破
Sequential And Linked Lists - 顺序表 和 链表 - 双向链表部分 - java(1)
2301_82257317的博客
04-30 523
前言博主突然记起来了！好像还漏一个双向链表没有写博客，今天就给大家补上。建议先看 这篇文章,再来看这篇双向，本篇文章可能相对粗略，所以建议你们先看单向链表的文章，有助于你们理解，直奔主题：单向链表 和 双向链表 的 数据结构（下面是不带头的）双向链表 和 单向链表的区别，就在于 双向 比 单向 多个 一个前驱地址。而且 你会发现 正因为有了前驱地址，所以所以这个链表，它有两种走向，这也是这个链表为什么叫做双向链表的原因之一。双向链表的好处节点删除，双向链表不需要借助前驱节点。
Sequential And Linked Lists - 顺序表 和 链表 - 单向链表部分 - java（图文并茂，你值得一看）(1)
2401_84048006的博客
05-13 776
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
顺序表与链表 比较
Hopefuling的博客
10-04 230
顺序表与链表 存储结构、适用情况等比较
数据结构：链表(Linked Lists)
//柏拉图的双斜杠
11-19 755
章节主题 链表简介 链表操作 双重链表 变化：尾部参考 变化：循环链接列表   Chapter Topics Introduction to Linked Lists  Linked List Operations Doubly Linked List Variation: Tail reference ...
线性结构及其应用的链表遍历与学号匹配操作实验报告
实验报告1主要涉及链表的遍历和应用，其中链表的遍历要考虑空表的情况并通过节点之间的联系进行遍历操作。实验要求收集两个班级的学生成绩信息并按降序排列，可以利用链表的插入和删除操作的良好特性，避免顺序存储...
TCP/IP协议栈之LwIP（一）---网络数据包管理
流云
07-02 8505
一、TCP/IP分层思想 直接看理论书籍不够直观高效，这个系列依然主要从如何实现的角度介绍TCP/IP协议。就像前面介绍操作系统，主要从比较简单的UCOS源码介绍操作系统的实现，对RTOS的实现有了深入的了解，再去阅读Linux的源码会更容易理解。这里介绍的TCP/IP系列也从相对轻量的LwIP协议栈源码的实现来介绍TCP/IP协议的原理和应用，LwIP协议源码如下：http://git.sava...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 330
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 395
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 719
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 692
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 573
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 914
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
spring task的使用场景
qq_40603125的博客
10-13 361
spring任务调度框架约定的时间。
Hex编码
weixin_74305514的博客
10-13 295
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
使用java实现顺序表和链表实现0到9的算法实例
09-15
在Java中，可以分别使用顺序表（数组）和链表数据结构实现从0到9的算法实例。这里我会提供简单的示例。 ### 1. 顺序表（数组实现） ```java public class SequentialList { private int[] list = new int[10]; // 初始化一个长度为10的顺序表 public void printNumbers() { for (int i = 0; i < 10; i++) { list[i] = i; // 将数字0到9逐个填充到数组中 System.out.print(list[i] + " "); // 打印每个元素 } System.out.println(); } } SequentialList sequentialList = new SequentialList(); sequentialList.printNumbers(); // 输出：0 1 2 3 4 5 6 7 8 9 ``` ### 2. 链表实现 ```java public class LinkedList { class Node { int data; Node next; Node(int data) { this.data = data; } } private Node head; public void printNumbers() { Node current = head; while (current != null) { current.data = current.data; // 虽然实际上不需要赋值，这是为了展示节点 System.out.print(current.data + " -> "); current = current.next; } System.out.println("null"); // 结尾添加null表示链表结束 } public void initialize() { head = new Node(0); for (int i = 1; i <= 9; i++) { Node newNode = new Node(i); newNode.next = head.next; head.next = newNode; } } public static void main(String[] args) { LinkedList linkedList = new LinkedList(); linkedList.initialize(); linkedList.printNumbers(); // 输出：0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值