LinkList——链表结构——JAVA

已于 2024-01-12 16:50:51 修改
阅读量418 收藏 8
点赞数 5
分类专栏： LinkList 文章标签： java 开发语言
于 2024-01-12 16:01:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkj000000/article/details/135539038
版权

LinkList——链表结构——JAVA

文章目录

一、readme

实现了：
增——（头插入，尾插入，后期任意位置插入）
删——(删除某个位置，删除某个具体data)
查——（查找某一位置的data，根据data查找所有位置）
改——（用新的data代替所有旧的data，在所有匹配的旧的data中用新的data代替特定选择的一个位置旧的data）

备注：思路在注释部分；
TArrayList 就是一个改写的一个数组 ，代码看->另外一篇文章——链接到：
希望指出错误和不足；

二、写代码部分

1.创建LNode类

public class LNode {
    /**
     * 定义结点结构
     * 1、数据 data
     * 2、指针 next（下一个结点）
     *
     * 写自己的构造方法
     *
     */
    public Object data;
    public LNode next;

    public LNode(Object data) {
        this.data = data;
    }
}

2.创建LNodeOp操作类

（0）总体框架


/**
 * 定义数据域
 * 1、头结点 head
 * 2、尾结点 last（就可以从实现尾插法的实现 O(1)）
 * 3、链表长度size
 *  .
 * 写方法{
 *     实现了以下方法：
 *     1、从尾部插入O（1）实现
 *          public void addLast(Object data)
 *     2、从头部插入O（1）实现
 *          public void add(Object data)
 *     3、返回index位置的节点的值
 *          public Object get(int index)
 *     4、返回所有值为data的节点的位置
 *          public TArrayList getPlace(Object data) 备注：这里的TArrayList对象是自己写的动态数组(包含扩容)
 *     5、删除index位置的节点  备注：head是第一个节点
 *          public Object remove(int index)
 *     6、删除所有值为data对象的节点
 *          public void removeObjects(Object data)
 *     7、在index位置插入data
 *          public void set(int index, Object data)
 *     8、用newObject取代所有的oldData;
 *          public void replaceObjects(Object oldData, Object newData)
 * }
 *
 */

（1） 写数据域——操作结点形成链表对象的

	/**
     * 定义数据域
     * 1、头结点 head
     * 2、尾结点 last（就可以从实现尾插法的实现 O(1)）
     * 3、链表长度size
     */
 	LNode head = null;
    LNode last = null;
    int size;

（2）尾插法插入新节点，实现O(1)，不再用while循环到最后了

	//从尾部插入O（1）实现

    /**
     *  思路：
     *  1、先创建一个新节点(要插入的）
     *  2、判断一下是否链表为空（head==null）的情况
     *  3、如果为空，则head和last指针就都指向这个新节点就好啦
     *  4、如果不为空，则让last指针指向新节点
     *      然后，last指针后移（更新last结点）
     *  5、size++
     */
    public void addLast(Object data) {
        LNode newNode = new LNode(data);
        if (head == null) {
            head = newNode;
            last = newNode;
            size++;
            return;
        }
        last.next = newNode;
        last = newNode;
        size++;

    }

（3）头插法插入新节点，实现O(1)

	//从头部插入O（1）实现

    /**
     *  思路：
     *  1、创建一个新的节点
     *  2、判断链表是否为空
     *  3、如果为空，那么head和last都指向新节点
     *  4、如果不为空，直接让newNode指向head；
     *      更新head到newNode（最前面）
     *  5、size++
     *  
     */
    
    public void addHead(Object data){
        LNode newNode =new LNode(data);
        if(head== null){
            head =newNode;
            last= newNode ;
            size++;
            return ;

        }
        newNode.next=head;
        head=newNode;
        size++;
    }

（4）返回index位置的节点的值

	//返回index位置的节点的值
    /**
     * 思路：
     *  1、判断index是否合法
     *  2、创建一个指针temp指向head
     *  3、for循环遍历index次，temp = temp.next
     *  4、返回temp.data
     */
    //head里面有data
    public Object get(int index) {
        if (index < 0 || index >= size) {
            return null;
        }
        LNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp.data;

    }

（5）返回所有值为data的节点的位置

  /**
     * 思路：
     *  1、创建一个TArrayList数组对象place(来返回所有位置)
     *  2、判断链表是否为空
     *  3、创建一个指针temp指向 head
     *  4、for循环遍历链表，如果temp.data == data，那么就把i添加到TArrayList对象中
     *  5、返回TArrayList数组对象
     * -
     *  备注：这里的TArrayList对象是自己写的动态数组(包含扩容)
     */
     public TArrayList getPlace(Object data) {
        TArrayList place = new TArrayList(10);
        if (head == null) {
            System.out.println("没有数据节点");
            return place;
        }
        LNode temp = head;
        int i = 0;
        while (temp != null) {
            if (temp.data.equals(data)) {
                place.addOneObject(i);
            }
            temp = temp.next;
            i++;
        }
        return place;
    }

（6）根据index，删除index位置的节点

	/**
     * 思路：
     *  1、判断index是否合法
     *  2、创建一个指针temp指向head
     *  3、for循环遍历index-1次，temp = temp.next
     *  4、创建一个对象e，把temp.next.data赋值给e
     *  5、temp.next = temp.next.next
     *  6、size--
     *  7、返回e
     *  备注：head是第一个节点
     */
      public Object remove(int index) {
        if (index < 0 || index >= size) {
            System.out.println("没有可删除的对象");
            return null;
        }
        LNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        Object e;
        e = temp.next.data;
        temp.next = temp.next.next;
        size--;
        return e;

    }

（7）删除所有值为data对象的节点

/**
     * 思路：
     *  1、判断链表是否为空
     *  2、创建一个指针temp指向head
     *  3、单独判断一下头结点，有存放data的，如果temp.data == data，那么head = head.next
     *  4、while循环遍历链表（要判断next），如果temp.next.data == data，那么temp.next = temp.next.next
     *  5、size--
     */
    public void removeObjects(Object data) {
        if (head == null) {
            System.out.println("没有可删除的对象");
            return;
        }
        LNode temp = head;
        if (temp.data.equals(data)) {
            head = head.next;
            size--;
        }
        while (temp.next != null) {
            if (temp.next.data.equals(data)) {
                temp.next = temp.next.next;
                size--;
            }
            temp = temp.next;
        }

    }

（8）在index位置插入data

 /**
     * 思路：
     *  1、判断index是否合法
     *  2、创建一个指针temp指向head
     *  3、for循环遍历index-1次，temp = temp.next
     *  4、创建一个新的节点newNode
     *  5、newNode.next = temp.next
     *  6、temp.next = newNode
     *  7、size++
     */
    public void set(int index, Object data) {
        if (index < 0 || index >= size) {
            System.out.println("没有可替换的对象");
            return;
        }
        LNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.data = data;
    }

（9）用newObject取代所有的oldData

 /**
     * 思路：
     *  1、判断链表是否为空
     *  2、创建一个指针temp指向head
     *  3、单独判断一下头结点，因为下面的循环不包括头结点的判断，如果temp.data == oldData，那么temp.data = newData
     *  4、while循环遍历链表，如果temp.next.data == oldData，那么temp.next.data = newData
     */
    public void replaceObjects(Object oldData, Object newData) {

        if (head == null) {
            System.out.println("没有可替换的对象");
            return;
        }
        LNode temp = head;
        if (temp.data.equals(oldData)) {
            temp.data = newData;
        }
        while (temp.next != null) {
            if (temp.next.data.equals(oldData)) {
                temp.next.data = newData;
            }
            temp = temp.next;
        }
    }

（10）在所有匹配的oldData列表中用新的data替换某一个oldData，（让用户选择）

	//得到所有匹配oldData的节点列表，然后让用户选择要替换的节点，然后替换
    /**
     * 思路：
     *  1、判断链表是否为空
     *  2、创建一个TArrayList数组对象place(来返回所有位置)
     *  3、创建一个指针temp指向head
     *  4、for循环遍历链表，如果temp.data == oldData，那么就把i添加到TArrayList对象中
     *  5、判断一下place.size是否为0，如果为0，那么就没有可替换的对象
     *  6、让用户输入要替换的对象的位置
     *  7、判断一下index是否合法，如果不合法，那么就没有可替换的对象
     *  8、set(index,newData)
     */
    public void replaceOneObject(Object oldData,Object newData){
        if(head==null){
            System.out.println("没有可替换的对象");
            return;
        }
        TArrayList place ;
        place=getPlace(oldData);//调用上面的方法；
        if(place.size==0){
            System.out.println("没有可替换的对象");
            return;
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要替换的对象的位置");
        int index=sc.nextInt();
        if(index<0||index>=place.size){
            System.out.println("没有可替换的对象");
            return;
        }
        set(index,newData);//调用上面的方法；

    }

附录完整代码如下：

package Linklist;

public class LNode {
    /**
     * 定义结点结构
     * 1、数据 data
     * 2、指针 next（下一个结点）
     *
     * 写构造方法
     *
     */
    public Object data;
    public LNode next;

    public LNode(Object data) {
        this.data = data;
    }


}


package Linklist;

import TArrayList.TArrayList;

import java.util.Scanner;

/**
 * 定义数据域
 * 1、头结点 head
 * 2、尾结点 last（就可以从实现尾插法的实现 O(1)）
 * 3、链表长度size
 *  .
 * 写方法{
 *     实现了以下方法：
 *     1、从尾部插入O（1）实现
 *          public void addLast(Object data)
 *     2、从头部插入O（1）实现
 *          public void add(Object data)
 *     3、返回index位置的节点的值
 *          public Object get(int index)
 *     4、返回所有值为data的节点的位置
 *          public TArrayList getPlace(Object data) 备注：这里的TArrayList对象是自己写的动态数组(包含扩容)
 *     5、删除index位置的节点  备注：head是第一个节点
 *          public Object remove(int index)
 *     6、删除所有值为data对象的节点
 *          public void removeObjects(Object data)
 *     7、在index位置插入data
 *          public void set(int index, Object data)
 *     8、用newObject取代所有的oldData;
 *          public void replaceObjects(Object oldData, Object newData)
 * }
 *
 */
public class LinkOp {



    /**
     * 定义数据域
     * 1、头结点 head
     * 2、尾结点 last（就可以从实现尾插法的实现 O(1)）
     * 3、链表长度size
     */
    LNode head = null;
    LNode last = null;
    int size;

    //从尾部插入O（1）实现

    /**
     *  思路：
     *  1、先创建一个新节点(要插入的）
     *  2、判断一下是否链表为空（head==null）的情况
     *  3、如果为空，则head和last指针就都指向这个新节点就好啦
     *  4、如果不为空，则让last指针指向新节点
     *      然后，last指针后移（更新last结点）
     *  5、size++
     */
    public void addLast(Object data) {
        LNode newNode = new LNode(data);
        if (head == null) {
            head = newNode;
            last = newNode;
            size++;
            return;
        }
        last.next = newNode;
        last = newNode;
        size++;

    }

    //从头部插入O（1）实现

    /**
     *  思路：
     *  1、创建一个新的节点
     *  2、判断链表是否为空
     *  3、如果为空，那么head和last都指向新节点
     *  4、如果不为空，直接让newNode指向head；
     *      更新head到newNode（最前面）
     *  5、size++
     *
     */

    public void addHead(Object data){
        LNode newNode =new LNode(data);
        if(head== null){
            head =newNode;
            last= newNode ;
            size++;
            return ;

        }
        newNode.next=head;
        head=newNode;
        size++;
    }
    //返回index位置的节点的值
    /**
     * 思路：
     *  1、判断index是否合法
     *  2、创建一个指针temp指向head
     *  3、for循环遍历index次，temp = temp.next
     *  4、返回temp.data
     */
    //head里面有data
    public Object get(int index) {
        if (index < 0 || index >= size) {
            return null;
        }
        LNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp.data;

    }


    //返回所有值为data的节点的位置
    /**
     * 思路：
     *  1、创建一个TArrayList数组对象place(来返回所有位置)
     *  2、判断链表是否为空
     *  3、创建一个指针temp指向 head
     *  4、for循环遍历链表，如果temp.data == data，那么就把i添加到TArrayList对象中
     *  5、返回TArrayList数组对象
     *  备注：这里的TArrayList对象是自己写的动态数组(包含扩容)
     */
    public TArrayList getPlace(Object data) {
        TArrayList place = new TArrayList(10);
        if (head == null) {
            System.out.println("没有数据节点");
            return place;
        }
        LNode temp = head;
        int i = 0;
        while (temp != null) {
            if (temp.data.equals(data)) {
                place.addOneObject(i);
            }
            temp = temp.next;
            i++;
        }
        return place;
    }

    //根据index，删除index位置的节点
    /**
     * 思路：
     *  1、判断index是否合法
     *  2、创建一个指针temp指向head
     *  3、for循环遍历index-1次，temp = temp.next
     *  4、创建一个对象e，把temp.next.data赋值给e
     *  5、temp.next = temp.next.next
     *  6、size--
     *  7、返回e
     *  备注：head是第一个节点
     */
    public Object remove(int index) {
        if (index < 0 || index >= size) {
            System.out.println("没有可删除的对象");
            return null;
        }
        LNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        Object e;
        e = temp.next.data;
        temp.next = temp.next.next;
        size--;
        return e;

    }

    //删除所有值为data对象的节点
    /**
     * 思路：
     *  1、判断链表是否为空
     *  2、创建一个指针temp指向head
     *  3、单独判断一下头结点，有存放data的，如果temp.data == data，那么head = head.next
     *  4、while循环遍历链表（要判断next），如果temp.next.data == data，那么temp.next = temp.next.next
     *  5、size--
     */
    public void removeObjects(Object data) {
        if (head == null) {
            System.out.println("没有可删除的对象");
            return;
        }
        LNode temp = head;
        if (temp.data.equals(data) ) {
            head = head.next;
            size--;
        }
        while (temp.next != null) {
            if (temp.next.data.equals(data)) {
                temp.next = temp.next.next;
                size--;
            }
            temp = temp.next;
        }

    }

    //在index位置插入data
    /**
     * 思路：
     *  1、判断index是否合法
     *  2、创建一个指针temp指向head
     *  3、for循环遍历index-1次，temp = temp.next
     *  4、创建一个新的节点newNode
     *  5、newNode.next = temp.next
     *  6、temp.next = newNode
     *  7、size++
     */
    public void set(int index, Object data) {
        if (index < 0 || index >= size) {
            System.out.println("没有可替换的对象");
            return;
        }
        LNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.data = data;
    }

    //用newObject取代所有的oldData
    /**
     * 思路：
     *  1、判断链表是否为空
     *  2、创建一个指针temp指向head
     *  3、单独判断一下头结点，因为下面的循环不包括头结点的判断，如果temp.data == oldData，那么temp.data = newData
     *  4、while循环遍历链表，如果temp.next.data == oldData，那么temp.next.data = newData
     */
    public void replaceObjects(Object oldData, Object newData) {

        if (head == null) {
            System.out.println("没有可替换的对象");
            return;
        }
        LNode temp = head;
        if (temp.data.equals(oldData) ) {
            temp.data = newData;
        }
        while (temp.next != null) {
            if (temp.next.data .equals(oldData)) {
                temp.next.data = newData;
            }
            temp = temp.next;
        }
    }

    //得到所有匹配oldData的节点列表，然后让用户选择要替换的节点，然后替换
    /**
     * 思路：
     *  1、判断链表是否为空
     *  2、创建一个TArrayList数组对象place(来返回所有位置)
     *  3、创建一个指针temp指向head
     *  4、for循环遍历链表，如果temp.data == oldData，那么就把i添加到TArrayList对象中
     *  5、判断一下place.size是否为0，如果为0，那么就没有可替换的对象
     *  6、让用户输入要替换的对象的位置
     *  7、判断一下index是否合法，如果不合法，那么就没有可替换的对象
     *  8、set(index,newData)
     */
    public void replaceOneObject(Object oldData,Object newData){
        if(head==null){
            System.out.println("没有可替换的对象");
            return;
        }
        TArrayList place ;
        place=getPlace(oldData);//调用上面的方法；
        if(place.size==0){
            System.out.println("没有可替换的对象");
            return;
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要替换的对象的位置");
        int index=sc.nextInt();
        if(index<0||index>=place.size){
            System.out.println("没有可替换的对象");
            return;
        }
        set(index,newData);//调用上面的方法；

    }
}
Lucky ＆powerful
关注
专栏目录
LinkList_链表_C语言_
10-02
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中是连续存储的，而是通过指针来链接各个元素，这使得在插入和删除操作上具有...
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5268
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
LinkedList的常见使用方法
weixin_72083767的博客
11-29 804
LinkedList的常见使用方法
数据结构：单链表（LinkList）基本操作的算法描述（C语言）
weixin_70911939的博客
04-06 866
数据结构：单链表（LinkList）基本操作的算法描述（C语言）
链表（Linked List）算法的使用场景和使用例子详解
一如既往的准备文章
03-05 2700
python复制代码。
【数据结构】链表和LinkedList的理解和使用
weixin_64173948的博客
09-24 343
在上一篇文章中我们介绍了顺序表，ArrayList的底层原理和具体的使用，但是当我们想进行频繁的插入和删除的时候，这种存储数据的方式，时间复杂度是O(N),这种数据结构并不适合平凡的插入和删除。那么有没有一种数据结构在进行这种操作的时候，时间复杂度为O(1)呢?那么本篇文章就给大家介绍一种，适合频繁的插入和删除操作的数据结构—链表，在进行这些操作的时候，它的时间复杂度为O(1).
Java数据结构之简单链表的定义与实现方法示例
08-29
Java数据结构之简单链表的定义与实现方法示例 Java数据结构之简单链表是指一种链式存储结构，通过节点之间的链接来存储数据。这种数据结构的特点是先进后出，即最后插入的数据将被最先删除。 定义 在Java中，简单...
ArrayList，LinkList链表接口实现.zip
10-03
ArrayList和LinkedList是Java集合框架中的两种重要数据结构，它们都实现了List接口，但各自有其独特的特性和使用场景。在本教程中，我们将深入探讨这两种数据结构的实现，并结合Eclipse IDE进行实践。 首先，...
Java员工管理系统-链表
04-10
基于此需求，我们开发了一款基于Java的员工管理系统，该系统利用链表和二叉排序树这两种数据结构来存储和管理公司的员工信息。 #### 二、主要功能模块 ##### 1. 部门枚举 - **定义**：首先定义了一个`Dept`枚举...
JAVA单向链表的实现.pdf
最新发布
06-26
### JAVA单向链表的实现知识点详解 #### 一、链表基础概念 在深入了解Java单向链表的具体实现之前，我们首先需要了解链表的基本概念。链表是一种线性数据结构，它由一系列节点组成，每个节点包含两部分：数据域和...
集合—LinkedList底层结构
lidong777777的博客
07-27 498
本次博客带领大家学习集合中的LinkedList底层结构。
数据结构linklist实现添加、插入、删除元素
weixin_46529416的博客
10-18 1013
【代码】数据结构linklist实现添加、插入元素。
25、集合——LinkedList
AQUROEAN
07-23 391
定义 List 接口的链接列表实现 构造方法 public LinkedList(Collection c)构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列 成员方法 public void addFirst(E e)将指定元素插入此列表的开头 public void addLast(E e)将指定元素添加到此列表的结尾 public E removeFirst()移除并返回此列表的第一个元素 public E removeLast()移除
链表（LinkList）的构造及其相关操作
weixin_61787820的博客
10-16 4401
数据结构：链表
6、LinkList的使用
yummy的博客
03-12 1191
6、LinkList的使用 （1）使用链表结构实现、增删快但是查询慢 添加元素 //创建链表集合 LinkedList linkedList=new LinkedList (); //添加元素 Student s1=new Student ("lym",10); Student s2=new Student ("yummy",10); Student s3=new Student ("happy",10);
【数据结构】LinkedList原理及实现学习总结
简约人生的博客
04-20 2万+
LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。二、ListedList类定义public class Lin
LinkedList中的链表结构
charxupengfei的博客
09-19 315
LinkedList ****类似链表结构，查询慢，增删快，线程不安全。** 双链表实现了List和Deque接口。 实现所有可选列表操作，并允许所有元素（包括null ）。 所有的操作都能像双向列表一样预期。 索引到列表中的操作将从开始或结束遍历列表，以更接近指定的索引为准。 请注意，此实现不同步。 如果多个线程同时访问链接列表，并且至少有一个线程在结构上修改列表，则必须在外部进行同步。 （结构修改是添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。）这通常通过在自然封装列表的对象上进行同
数据结构：链表(linked-list)
热门推荐
蜗牛君的奋斗史
05-09 5万+
链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。
06 | 链表（上）：如何实现LRU缓存淘汰算法?
ChinaDragon10的博客
11-01 430
今天我们来聊聊“链表（Linked list）”这个数据结构。学习链表有什么用呢？为了回答这个问题，我们先来讨论一个经典的链表应用场景，那就是 LRU 缓存淘汰算法。 缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。 缓存的大小有限，当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留？这就需要缓存淘汰策略来决定。常见的策略有三种：先进先出策略 FIFO（First In，First Out）、最少使用策略 LFU（.
航空订票系统数据结构设计——链表操作
2. **订单链表（Linklist）**：用于存储已订票的客户信息。每个节点（`ord_ros`）包括客户姓名、订票量和舱位等级，同样使用指针`next`链接下一个节点。定义了一个指向链表头的指针`order`，存储在`struct airline`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值