Java【链表操作】

最新推荐文章于 2024-01-26 08:48:02 发布
最新推荐文章于 2024-01-26 08:48:02 发布
阅读量72 收藏
点赞数
分类专栏： 笔记 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36465520/article/details/103241104
版权

建立单列表节点类

package org.article.node;

import lombok.Data;

/**
 * @Author: yangyang7
 * @Description: 单链表节点
 * @Date: Created in 09:28 2019-11-25
 */

@Data
public class Node {

    /**
     * 数据域
     */
    private int data;

    /**
     * 指针域
     */
    private Node next;

    public Node(int data) {
        this.data = data;
    }
}

建立单链表类

package org.article.node;

import lombok.Data;

/**
 * @Author: yangyang7
 * @Description: 建立简单的单链表
 * @Date: Created in 09:30 2019-11-25
 */

@Data
public class SLinkList {

    private Node head;

    /**
     * 节点的长度
     */
    private int length = 0;

    public SLinkList() {
        this.head = null;
    }

    /**
     * 在链表头部添加节点
     */
    public void addHead(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            newNode.setNext(head);
            head = newNode;
        }
        length++;
    }

    /**
     * 在链表头部删除节点
     */
    public void deleteHead() {
        if (head == null) {
            System.out.println("链表为空");
            return;
        }
        Node curNode = head;
        head = curNode.getNext();
        length--;
    }

    /**
     * 在链表尾部添加节点
     */
    public void addTail(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node preNode = head;
            int count = 1;
            while (count < length) {
                preNode = preNode.getNext();
                count++;
            }
            Node curNode = preNode.getNext();
            newNode.setNext(curNode);
            preNode.setNext(newNode);
            length++;
        }
    }

    /**
     * 在链表尾部删除节点
     */
    public void deleteTail() {
        if (head == null) {
            System.out.println("链表为空");
            return;
        }
        Node preNode = head;
        int count = 1;
        while (count < length - 1) {
            preNode = preNode.getNext();
            count++;
        }
        Node curNode = preNode;
        preNode.setNext(curNode.getNext());
        length--;
    }

    /**
     * 在链表指定位置插入节点
     */
    public void insertList(int index, int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        }
        if (index < length || index < 0) {
            System.out.println("没有指定节点位置");
            return;
        }
        if (index == 1) {
            // 在头部插入
            head.setNext(head);
            head = newNode;
        } else {
            Node preNode = head;
            int count = 1;
            while (count < index - 1) {
                preNode = newNode.getNext();
                count++;
            }
            Node curNode = preNode.getNext();
            preNode.setNext(newNode);
            newNode.setNext(curNode);
        }
        length++;
    }

    /**
     * 在链表指定位置删除节点
     */
    public void deleteList(int index) {
        if (head == null) {
            System.out.println("链表为空");
            return;
        }
        if (index == 1) {
            // 删除头部
            Node curNode = head;
            head = curNode.getNext();
            length--;
            return;
        } else {
            Node preNode = head;
            int count = 1;
            while (count < index - 1) {
                preNode = preNode.getNext();
                count++;
            }
            Node curNode = preNode.getNext();
            preNode.setNext(curNode.getNext());
            length--;
        }
    }


    /**
     * 获取指定位置的节点
     *
     * @param index
     * @return
     */
    public Node getIndexData(int index) {
        if (head == null) {
            System.out.println("空表");
            return null;
        }
        if (index > length || index < 1) {
            System.out.println("节点位置不存在,可查询的位置为1到" + length);
            return null;
        }
        Node preNode = head;
        int count = 1;
        while (count != index) {
            preNode = preNode.getNext();
            count++;
        }
        System.out.println(preNode);
        return preNode;
    }

    /**
     * 修改指定位置节点数据
     *
     * @param index
     * @param data
     */
    public void updateIndexData(int index, int data) {
        if (head == null) {
            System.out.println("空表");
        }
        if (index > length || index < 1) {
            System.out.println("节点位置不存在,可查询的位置为1到" + length);
        }
        Node preNode = head;
        int count = 1;
        while (count != index) {
            preNode = preNode.getNext();
            count++;
        }
        preNode.setData(data);
    }
}

建立双向列表节点类

package org.article.node;

import lombok.Data;

/**
 * @Author: yangyang7
 * @Description:
 * @Date: Created in 16:47 2019-11-25
 */

@Data
public class DNode {

    /**
     * 数据域
     */
    private int data;

    /**
     * 后驱指针域
     */
    private DNode next;

    /**
     * 前驱指针域
     */
    private DNode previous;

    public DNode(int data) {
        this.data = data;
    }
}

建立双向链表类

package org.article.node;

import lombok.Data;

/**
 * @Author: yangyang7
 * @Description: 双向链表类
 * @Date: Created in 16:50 2019-11-25
 */

@Data
public class DLinkList {

    /**
     * 表头
     */
    private DNode head;
    private int length = 0;

    public DLinkList() {
        this.head = null;
    }

    /**
     * 在链表头部添加结点
     *
     * @param data
     */
    public void addHead(int data) {
        DNode newNode = new DNode(data);
        if (head == null) {
            //如果链表为空，增加新结点
            head = newNode;
        } else {
            newNode.setNext(head);
            head.setPrevious(newNode);
            head = newNode;
        }
        length++;
    }

    /**
     * 在链表头部删除结点
     */
    public void deleteHead() {
        if (head == null) {
            System.out.println("空表，删除的结点不存在");
        } else {
            DNode curNode = head;
            head = curNode.getNext();
            head.setPrevious(null);
        }
        length--;
    }

    /**
     * 在链表尾部添加结点
     *
     * @param data
     */
    public void addTail(int data) {
        DNode newNode = new DNode(data);
        if (head == null) {
            head = newNode;
        } else {
            DNode curNode = head;
            int count = 1;
            while (count < length) {
                curNode = curNode.getNext();
                count++;
            }
            newNode.setNext(null);
            newNode.setPrevious(curNode);
            curNode.setNext(newNode);
        }
        length++;
    }

    /**
     * 在链表尾部删除结点
     */
    public void deleteTail() {
        if (head == null) {
            System.out.println("空表，删除的结点不存在");
        } else {
            DNode preNode = head;
            int count = 1;
            while (count < length - 1) {
                preNode = preNode.getNext();
                count++;
            }
            preNode.setNext(null);
        }
        length--;
    }


    /**
     * 在指定位置插入结点
     *
     * @param data
     * @param index
     */
    public void insertList(int data, int index) {
        DNode newNode = new DNode(data);
        if (head == null) {
            head = newNode;//链表为空，插入
        }
        if (index > length + 1 || index < 1) {
            System.out.println("结点插入的位置不存在，可插入的位置为1到" + (length + 1));
        }
        if (index == 1) {
            newNode.setNext(head);
            head.setPrevious(newNode);
            head = newNode;//在链表开头插入
        } else {              //在链表中间或尾部插入
            DNode preNode = head;
            int count = 1;
            while (count < index - 1) {
                preNode = preNode.getNext();
                count++;
            }
            DNode curNode = preNode.getNext();
            newNode.setNext(curNode);
            newNode.setPrevious(preNode);
            preNode.setNext(newNode);

            curNode.setPrevious(newNode);

        }
        length++;
    }

    /**
     * 在指定位置删除结点
     *
     * @param index
     */
    public void deleteList(int index) {
        if (index > length || index < 1) {
            System.out.println("结点删除的位置不存在，可删除的位置为1到" + length);
        }
        if (index == 1) {
            DNode curNode = head;
            head = curNode.getNext();
            head.setPrevious(null);
            length--;
        } else {
            DNode preNode = head;
            int count = 1;
            while (count < index - 1) {
                preNode = preNode.getNext();
                count++;
            }
            DNode curNode = preNode.getNext();
            DNode laterNode = curNode.getNext();
            preNode.setNext(laterNode);
            if (laterNode != null) {  //若被删除结点的后继结点不是null结点，那么设置其前驱结点
                laterNode.setPrevious(preNode);//指针指向被删除结点的前驱结点
            }
            length--;
        }
    }

    /**
     * 获取指定位置的数据，与单链表一样
     *
     * @param index
     */
    public void getIndexData(int index) {
        if (head == null) {
            System.out.println("空表");
        }
        if (index > length || index < 1) {
            System.out.println("结点位置不存在，可获取的位置为1到" + length);
        }
        DNode curNode = head;
        int count = 1;
        while (count != index) {
            curNode = curNode.getNext();
            count++;
        }
        System.out.println(curNode);
        System.out.println();
    }

    /**
     * 修改指定位置的结点数据，与单链表一样
     *
     * @param index
     * @param data
     */
    public void updateIndexData(int index, int data) {
        if (head == null) {
            System.out.println("空表");
        }
        if (index > length || index < 1) {
            System.out.println("结点位置不存在，可更新的位置为1到" + length);
        }
        DNode curNode = head;
        int count = 1;//while也可以用for循环方式解决
        while (count != index) {
            curNode = curNode.getNext();
            count++;
        }
        curNode.setData(data);
    }
}
请你吃代码去不去
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java给链表赋值_Java链表操作代码
weixin_35995565的博客
02-12 2011
/****/packagecom.cherish.SwordRefersToOffer;/***@authoracer**/public classtest_22链表中倒数第k个节点 {/****/publictest_22链表中倒数第k个节点() {//TODO 自动生成的构造函数存根}public static classListNode{private intval;ListNode ...
Java链表总结
m0_56987404的博客
05-04 1335
链表简单的curd操作入门
Java中链表操作
qq_41541801的博客
03-14 757
import java.util.LinkedList; public class LinkedListTest { public static void main(String[] args) { // 创建一个链表 LinkedList<Integer> list = new LinkedList<>(); // 添加元素 // 时间复杂度：O(1) list.add(1);
Java链表基础
qq_46638003的博客
01-07 2152
以上是对链表的基础操作,大部分都是通过遍历链表实现.
Java链表入门(超详细)
热门推荐
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
JAVA链表操作
大白
04-25 8886
数据结构学习 建立单链表节点类 package com.qcby.data; public class Node { private int data; //数据域 private Node next; //指针域 public Node(int data) { this.data = data; } public int getData() { re...
java链表的基本操作
m0_52261367的博客
03-20 3398
一，定义节点类 //定义节点类 public class ListNode { int val;//数据域 ListNode next;//指针域 ListNode() {}//构造方法 ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } 二、创建一个新的节点。ListNode
【Java】轻松掌握链表操作
叮当猫的博客
03-25 2225
基于节点的数据结构——链表1.1 什么是链表1.2 链表的读取与查找1.3 链表的插入1.4 链表的删除1.5 链表 vs 数组 1.1 什么是链表 在数组存储的过程中，数组的存储必须使用连续的内存空间，并且会预留一部分空间方便扩展。这样在内存中会大大降低内存的使用率，这种事情是不被接受的。所以出现了一种新的数据结构，叫作——链表 综上可知：链表的发明其实是对数组的一种补充。因此它的功能和数组非常类似，都是用于存储一系列相同类型的数组，并且都有增删改查等基本操作 用一句话来总结： 数组能做的所有事情，一般
Java链表（1）
m0_74270127的博客
01-26 1781
什么是链表，链表的种类，单链表中常见方法的模拟实现
java给链表赋值_java链表的各种操作
weixin_31746993的博客
02-12 3420
java里面没有指针的说法，所以初始化的时候，就是新建一个null节点就是一个空链表了。//C里面链表会有头指针，头指针指向头节点如果想向空链表插入第一个节点，直接head=newNode；注意的情况是如果想循环链表，一定新建一个节点把head考出来，然后遍历，不能直接用head遍历/*** Created by Administrator on 2017-10-27.*/public class...
Java实现链表的常见操作算法详解
08-25
Java中的链表是一种重要的数据结构，它通过节点之间的引用关系形成线性序列。与数组不同，链表不依赖于连续的内存空间，因此在插入和删除操作上...在实际开发中，根据需求，还可以扩展更多的链表操作，如排序、分隔等。
java实现链表操作
10-24
用java实现了数据结构中的链表，作为新手学习数据结构和java的资料。
java链表反转及排序
09-01
在“java链表反转及排序”这个主题中，我们将探讨如何在Java中实现单向链表的反转和排序。首先，我们创建一个链表节点类，包含数据和指向下一个节点的引用： ```java public class ListNode { int val; // 节点值 ...
java实现链表
09-24
链表是一种物理存储单元上非连续、非顺序的存储结构。 java代码实现单链表，插入，删除和遍历等功能。 链表能够灵活的进行插入和删除操作，时间复杂度为O（1）,链表的查找时间复杂度为O（n）。
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
cykooz.resizer-3.0.0-cp310-cp310-macosx_11_0_arm64.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]Delphi题库管理与试卷自动生成系统.zip
最新发布
07-27
[毕设]Delphi题库管理与试卷自动生成系统
131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+图像识别与定位+该数据集相关的研究论文
07-27
<项目介绍> 包含131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+该数据集相关的研究论文。可供深度学习图像识别与定位。 - 训练集大小：67700 个图像 测试集大小：22888 个图像 文件名格式：image_index_100.jpg（例如 32_100.jpg）或 r_image_index_100.jpg（例如 r_32_100.jpg）或 r2_image_index_100.jpg 或 r3_image_index_100.jpg。 “r”代表旋转水果。 “r2”表示水果绕第三轴旋转。 “100”来自图像尺寸（100x100 像素）。 水果是如何拍摄的: 1:使用 C920 摄像机拍摄水果。最好的网络摄像头之一。 2:在水果后面，我们放了一张白纸作为背景。 3:将水果和蔬菜种植在低速电机（3转/分钟）的轴中，并录制一段20秒的短片。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
Java链表操作：构建与遍历
"Java电子书中的链表操作实例" 在Java编程中，链表是一种重要的数据结构，它不依赖于数组的连续内存空间，而是通过节点间的引用关系连接。本电子书中提到了一个关于链表操作的问题，主要涉及到创建链表、插入节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值