java编程(一)链表

Java中的链表结构:从单链表到双向链表 本文深入探讨了Java中不同类型的链表结构,包括单向链表、双向链表及其操作方法。文中通过具体Java代码实例展示了如何创建和管理链表,包括插入、删除和遍历元素等操作。特别地,详细解释了双向链表的节点结构和特点,以及如何实现双向链表的增删查等功能。 阅读详情

1.单链表

package unLinkedList;

package unLinkedList;

public interface IList {

    //判断是否为空
    public boolean isEmpty();

    //插入元素
    public void insert(int index,Object o)throws Exception;

    //删除元素
    public void delete(int index)throws Exception;

    //获取链表长度
    public int getLength();

    //获取元素
    public Object get(int index)throws Exception;



}

//单向链表
public class UNode {

    //数据域
    Object obj;
    //指针
    UNode next;

    public UNode(UNode nextval){
        this.next=nextval;
    }

    public UNode(Object obj,UNode nextval){
        this.next=nextval;
        this.obj=obj;
    }

    public UNode getNext(){
        return this.next;
    }

    public void setNext(UNode nextval){
        this.next=nextval;
    }

    public Object getObj(){
        return this.obj;
    }

    public void setObj(Object obj){
        this.obj=obj;
    }


    public String toString(){
        return this.obj.toString();
    }
}

package unLinkedList;

//单向链表
public class UnLinkedList implements IList{
    //头指针
    UNode head;
    //当前节点对象
    UNode cur;
    int size;

    //初始化
    public UnLinkedList(){
        this.head=cur=new UNode(null);
        this.size=0;
    }

    //指针定位,定位到插入节点之前的一个节点
    public void index(int index)throws Exception{
        if(index<-1 || index>size-1){
            System.out.println("错误!");
        }
        //头结点
        if(index==-1)
            return;
        cur=head.next;
        int j=0;
        while (cur!=null && j<index){
            cur=cur.next;
            j++;
        }
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void insert(int index, Object o) throws Exception {
        if(index<0 || index>size){
            throw new Exception("参数错误!");
        }
        //插入节点的前一个节点
        index(index-1);
        cur.setNext(new UNode(o,cur.next));
        size++;
    }

    @Override
    public void delete(int index) throws Exception {
        if(isEmpty()){
            throw new Exception("链表为空,删除错误!");
        }
        if(index<0 || index>size){
            throw new Exception("传入参数错误!");
        }
        //定位到删除节点之前的一个节点
        index(index-1);
        cur.setNext(cur.next.next);
        size--;
    }

    @Override
    public int getLength() {
        return this.size;
    }

    @Override
    public Object get(int index) throws Exception {
        if (index<-1 || index>size-1){
            throw new Exception("传入参数错误!");
        }
        index(index);
        return cur.getObj();
    }

    public static void main(String[] args)throws Exception{
        UnLinkedList list=new UnLinkedList();
        for (int i = 0; i < 5; i++) {
            int temp=((int)(Math.random() * 1000)) * 1000;
            list.insert(i,temp);
            System.out.println(temp+"--");
        }

        list.delete(4);
        System.out.println("---------------------");
        for (int i = 0; i <list.size ; i++) {
            System.out.println(list.get(i)+"--");
        }

    }
}

2.双向循环链表

package unLinkedList;


//双向链表
public class DNode {
    //数据域
    Object obj;
    //后继针域
    DNode next;
    //前驱指针域
    DNode prior;

    public DNode(DNode nextval){
        this.next=nextval;
    }

    public DNode(Object obj, DNode nextval){
        this.next=nextval;
        this.obj=obj;
    }

    public DNode getNext(){
        return this.next;
    }

    public void setNext(DNode nextval){
        this.next=nextval;
    }

    public Object getObj(){
        return this.obj;
    }

    public void setObj(Object obj){
        this.obj=obj;
    }

    public DNode getPrior(){
        return this.prior;
    }

    public void setPrior(DNode priorval){
        this.prior=priorval;
    }

    public String toString(){
        return this.obj.toString();
    }
}
package unLinkedList;

//双向链表
public class DLinkedList implements IList{

    //头指针
    DNode head;
    //当前节点对象
    DNode cur;
    int size;

    //初始化
    public DLinkedList(){
        this.head=cur=new DNode(null);
        this.size=0;
        this.head.next=head;
        this.head.prior=head;
    }

    //指针定位,定位到插入节点之前的一个节点
    public void index(int index)throws Exception{
        if(index<-1 || index>size-1){
            System.out.println("错误!");
        }
        //头结点
        if(index==-1)
            return;
        cur=head.next;
        int j=0;
        while (cur!=head && j<index){
            cur=cur.next;
            j++;
        }
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void insert(int index, Object o) throws Exception {
        if(index<0 || index>size){
            throw new Exception("参数错误!");
        }
        //插入节点的前一个节点
        index(index-1);
        cur.setNext(new DNode(o,cur.next));
        cur.next.setPrior(cur.next);
        cur.next.next.setPrior(cur.next);
        size++;
    }

    @Override
    public void delete(int index) throws Exception {
        if(isEmpty()){
            throw new Exception("链表为空,删除错误!");
        }
        if(index<0 || index>size){
            throw new Exception("传入参数错误!");
        }
        //定位到删除节点之前的一个节点
        index(index-1);
        cur.setNext(cur.next.next);
        cur.next.setPrior(cur);
        size--;
    }

    @Override
    public int getLength() {
        return this.size;
    }

    @Override
    public Object get(int index) throws Exception {
        if (index<-1 || index>size-1){
            throw new Exception("传入参数错误!");
        }
        index(index);
        return cur.getObj();
    }


    public static void main(String[] args)throws Exception{
        DLinkedList list=new DLinkedList();
        for (int i = 0; i < 5; i++) {
            int temp=((int)(Math.random() * 1000)) * 1000;
            list.insert(i,temp);
            System.out.println(temp+"--");
        }

        list.delete(4);
        System.out.println("---------------------");
        for (int i = 0; i <list.size ; i++) {
            System.out.println(list.get(i)+"--");
        }
    }
}

3.链表反转

package unLinkedList;


public class reverseList {
    public static UNode reverseList(UNode head){
        //前一个节点的指针
        UNode preNode=null;
        //当前节点指针
        UNode curNode=head;
        //下一个节点指针
        UNode nextNode=null;

        //如果首节点为空
        if(head==null || head.getNext()==null){
            return head;
        }

        //首节点不为空
        while (curNode!=null){
            //前后节点交换
            nextNode=curNode.getNext();
            curNode.setNext(preNode);
            preNode=curNode;
            curNode=nextNode;
        }

        return preNode;
    }
}

4.合并链表、求链表中间节点

package unLinkedList;

package unLinkedList;

public class MNode {

        //数据域
        int obj;
        //指针
        MNode next;

        public MNode(int obj){
            this.obj=obj;
        }

        public MNode(int obj,MNode nextval){
            this.next=nextval;
            this.obj=obj;
        }

        public MNode getNext(){
            return this.next;
        }

        public void setNext(MNode nextval){
            this.next=nextval;
        }

        public Object getObj(){
            return this.obj;
        }

        public void setObj(int obj){
            this.obj=obj;
        }




}


//将两个有序链表合并
/*
*@param node1有序链表1
*@param node2有序链表2
*@return 合并后的链表
* */
public class mergeList {
    public static MNode mergeList(MNode node1, MNode node2) {

        //使用递归的方式进行合并,终止条件
        if (node1 == null && node2 == null) {
            return null;
        }
        if (node1 == null) {
            return node2;
        }
        if (node2 == null) {
            return node1;
        }


        //合并后的链表
        MNode node = null;
        //为了方便,这里将数据类型转换为Int
        if ((int) node1.obj > (int) node2.obj) {
            //小的放在前面
            node = node2;
            node.next = mergeList(node1, node2.next);
        } else {
            node = node1;
            node.next = mergeList(node2, node1.next);
        }

        return node;
    }

    //求链表中间节点
    public static MNode middleNode(MNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        MNode slow = head;
        MNode fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return fast == null ? slow : slow.next;
    }


    public static void main(String[] args) throws Exception {

        MNode node1 = new MNode(1);
        MNode node2 = new MNode(2);
        MNode node3 = new MNode(3);
        MNode node4 = new MNode(4);
        MNode node5 = new MNode(5);

        node1.next = node3;
        node3.next = node5;
        node2.next = node4;

        MNode node = mergeList(node2, node1);
        while (node != null) {
            System.out.print(node.obj + " ");
            node = node.next;

        }
    }
}

 

数据结构实验线性表(用java创建顺序表与链表并解决实验题目) 实验内容: (1)创建一个顺序表,存放在数组 A[N]中,元素的类型为整型,设计算法调整 A,使其左边的所有元素小于 0,右边的所有元素大于 0(要求算法的时间复杂度和空间复杂度均为 O(n))。 (2)建立一个循环单链表,其节点有 prior,data 和 next 三个域,其中 data 为数 据域,存放元素的有效信息,next 域为指针域,指向后继节点,prior 为指针域,它的值为 NULL。编写一个算法将此表改为循环双链表。 立即下载

相关推荐

机器人系统能用MQTT5.0代替ROS2吗?

更为灵活和友好的方案是通过把ROS(Robot Operating System)与MQTT(Message Queuing Telemetry Transport)协议相结合的解决方案,利用MQTT的轻量级、跨平台和广泛适用性特点,扩展ROS系统的通信能力,或将非ROS系统接入ROS网络。

QzmAIoT 2165

JAVA——链表

一、链表概念及结构 链表:链表是一种物理存储结构上非连续存储结构,数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图:(通俗的说:就是由一个个节点组成,这些节点逻辑上连续,物理上不连续) 类比火车: singleLinkedList ——火车车次(一整个火车or哪趟火车) Node——车厢,具体储存元素的类,每个单链表的节点就是Node的一个对象 Node.head ;——当前链表的头节点(只要知道头节点就可以此访问链表中的所有节点) int size ;——当前链表的长度(节点个.

qq_69133469的博客 3万+

docker 安装oracle

本文介绍了使用Docker部署Oracle数据库的实践指南。主要内容包括:常用Oracle镜像的阿里云和华为云拉取地址,11g/12c/19c等不同版本的启动命令示例,以及连接数据库的基本信息。实战部分详细演示了Oracle 11g的安装过程,包括镜像拉取、容器启动、密码修改和数据库连接步骤,并通过Sql Developer和命令行两种方式创建用户。最后提到数据持久化的重要性,建议将数据库文件挂载到宿主机目录以防止容器删除导致数据丢失。文章提供了完整的操作命令和截图说明,适合需要快速部署Oracle测试环境

weixin_39766667的博客 378

【Java】链表LinkedList

链表(Linked List)是一种常见的数据结构,用于存储和组织数据。它由一系列节点(Node)组成,每个节点包含两个主要部分:数据域(Data)和指针域(Pointer)。 数据域存储节点所需的数据或信息,可以是任意类型的数据,如整数、字符、对象等。指针域则指向链表中的下一个节点,将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储,而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点,而无需像数组那样进行元素的移动。

qq_61635026的博客 1万+

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”,要求按下列格式打印

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”,要求按下列格式打印

ProceduralMan的博客 7412

若依(ruoyivue)实现文档在线查看

1、Kkfileview部署 第一步:从kkfileview官方发行版本下载安装包,安装包下载路径: https://gitee.com/kekingcn/file-online-preview/releases, 第二步:解压kkFileView-x.x.x文件(Windows用.zip包,Linux/MacOS用.tar.gz包) 第三步:打开解压后文件夹的bin目录,运行startup脚本(Windows下以管理员身份运行startup.bat,Linux以root用户运行startup.sh) 第四

weixin_46953697的博客 9682

Java数据结构篇之链表

/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】

MasterJundarj的博客 5518

农经权二轮延包—地块示意图生成

本文介绍了地块示意图制作软件的使用方法及模板制作要点。软件通过设置六个参数(示意图模板、属性数据、地块DBF、导航图、地块图片及存放位置)自动生成Word文档,并可导出PDF。文章详细说明了5页Word模板的制作过程,包括页脚三栏设置和页码插入技巧,支持每户最多28个地块的情况。同时指出该软件生成的图片分辨率(300dpi)满足清晰度要求,并提及软件免费提供插件但收费提供后续服务。

weixin_47364423的博客 1119

数据结构——链表(java)

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

薯条和番茄酱的博客 4707

PLSQL 14.0.6 下载使用教程

众所周知,PLSQL 只是一个oracle第三方开发测试工具,它依赖oracle 客户端搭配使用,但是oracle 客户端有2G,相当庞大,不建议安装。所以我们如果下载安装好PLSQL,再下载好轻量级的支持远程链接的oracle客户端,这样搭配使用可以的话就最好了,答案是可以的。 第一步: PLSQL 下载与安装 PLSQL 14.0.6 下载地址 : https://www.allroundautomations.com/registered-plsqldev/ 下载下来,除了安装路径更改一下,

qq976511508的博客 2137

YOLOv8实战:用Labelme标注自定义数据集并训练分割模型(附完整代码)

本文详细介绍了使用Labelme标注自定义数据集并训练YOLOv8实例分割模型的完整流程。从环境搭建、数据标注与格式转换,到模型训练、调优、验证及部署,提供了实战代码和调优建议。文章还探讨了如何结合追踪目标技术,实现视频流中的实例分割与目标追踪,为计算机视觉应用提供了一套可复制的解决方案。

553

Java链表入门(超详细)

说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表(Linkedlist)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....

qq_57735833的博客 2万+

RAG系统中Reranker模型选型实战

本文详细介绍了RAG系统中Reranker模型选型实战,希望能对学习RAG的同学们有所帮助。 文章目录 1. 前言 2. 思路解析 3. 测评数据集构建 3.1 步骤一 3.2 步骤二 3.3 数据示例 3.4 总结 4. 实战代码 4.1 本地模型 4.2 使用第三方的Reranker模型API

herosunly的博客 17万+

java简单链表

public class LinkedList<T> { Node<T> headNode = null; Node<T> tailNode = null; int count = 0; public LinkedList() { // TODO Auto-generated constructor stub tailNode = headNo...

dz789989的博客 209

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

牛客 NC189 给单链表加一【中等 链表 提供Java,Go答案】

【代码】牛客 NC189 给单链表加一【中等 链表 提供Java,Go答案】

weixin_37991016的博客 423

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

单向链表的反转Java实现

/递归修改当前节点的next节点,最终返回新的首节点。单向链表的反转Java实现如下。

wuqjwuqj2013的博客 764

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

反转链表(java)

【代码】反转链表(java)

m0_74779497的博客 172

java实现单链表反转

public class ReverseLink { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String str = scanner.nextLine(); char[] s = str.toCharArray(); NodeList[] n...

qq_34792830的博客 249

java 查找链表中间元素_java查找链表中间元素_如何通过Java单次查找链表的中间元素...

java查找链表中间元素您如何一次找到LinkedList的中间元素是一个编程问题,在电话采访中经常问Java和非Java程序员。 这个问题类似于检查回文或计算阶乘 ,有时Interviewer还会要求编写代码。 为了回答这个问题,候选人必须熟悉LinkedList的数据结构,即在单个LinkedList的情况下,Linked List的每个节点都包含数据和指针,这是下一个Linked List的...

weixin_42305264的博客 340

​LeetCode解法汇总143. 重排链表

这题如果使用额外的数据结构,比如把链接转换成数组,那么问题就会变得很简单,所以暂且把目标设置为不使用额外空间。* 重新遍历head链表,直到遍历到middle节点。每次遍历,head和foot链表各取一个。* 使用快慢指针的策略,快指针走两个节点,慢指针走一个节点,这样,我们可以找到中间节点。* 然后使用头插法,把中间节点后面的所有节点翻转,生成翻转链表foot。不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。* 链表长度5*10^4,所以递归的方式不可取。* 143. 重排链表。

分享+记录 563

算法:翻转链表_java实现

【代码】算法:翻转链表_java实现。

工匠精神coding,终生学习 189

L2-022 重排链表 - java

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址和结点总个数,即正整数N (≤。对每个测试用例,顺序输出重排后的结果链表,其上每个结点占一行,格式与输入相同。Next是下一结点的地址。题目保证给出的链表上至少有两个结点。Data是该结点保存的数据,为不超过。结点的地址是5位非负整数,NULL地址用−1表示。请按链表的 最后面一个和最前面一个的顺序 输出显示。如果有说错的 或者 不懂的 尽管提 嘻嘻。然后将list的一后一前拿出来输出。,请编写程序将链表重新排列为。先将链表的顺序安排出来。

谢谢 啊sir的博客 331

【链表】剑指Offer: 反转链表

【在线编程】反转链表 【问题描述】 输入一个链表,反转链表后,输出新链表的表头。 【解题思路 & Java实现】 方法一: 前后指针法,原地逆转, 注意最终返回pre。 /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = v...

journey_TripleP的博客 185

利用双向循环链表实现长整数的存储_链表看这一篇真的就够了!

前言有的小伙伴说没有学过数据结构,对链表不是特别了解,所以今天我们就来对链表进行一个系统的总结,另外大家如果想提高算法思想的话,我建议还是要系统的学一下数据结构的。阅读完本文你会有以下收获1.知道什么是链表?2.了解链表的几种类型。3.了解链表如何构造。4.链表的存储方式5.如何遍历链表6.了解链表的操作。7.知道链表和数组的不同点8.掌握链表的经典题目。链表的定义:定义:链表是一种递归...

weixin_39618169的博客 406

【力扣题解】817. 链表组件

链表

爱做梦的猪的博客 273

算法-链表-92.反转链表||

【代码】算法-链表-92.反转链表||

2301_76799207的博客 302
上一篇: MySQL 实战 - 复杂项目
下一篇: java编程(一)队列
vegetableChick
博客等级 码龄11年 7粉丝 19原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值