java实现链表的增删改查

最新推荐文章于 2024-01-27 16:26:35 发布
最新推荐文章于 2024-01-27 16:26:35 发布
阅读量902 收藏
点赞数
分类专栏： java学习记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50901244/article/details/121673456
版权
本文详细介绍了如何使用Java实现单链表的常见操作，包括在链表头部和中间位置插入元素、查找指定位置的元素、检查元素是否存在、修改链表中的值、按索引和值删除元素。提供了完整的代码实现，包括节点类Node和单链表类SingleLinkedList，以及相关方法的逻辑解析。
摘要由CSDN通过智能技术生成

1.链表的增加

1.1 链表头部增加addFirst(int val)

  • 先创建节点 Node node = new node(val);
  • 判断头部是否为空，若为空，head=node;头部不为空，让新建的节点指向头部，node.next=head;头指针再指向新建节点head=node;
    注意：如果不清除指向的先后顺序，可以画图帮助判断。如若各种指向顺序都不行，建立临时变量
    public void addFirst(int val){
        // 先创建需要挂载的车厢节点
        Node node =new Node(val);
        // 判断火车头部是否为空
        if (head==null){
            head=node;
        }
        // 火车有节点，要将当前新车厢挂载到火车头节点上
        else{
            // 新车厢指向head头节点
            node.next=head;
            // 新的头节点再指向之前的头节点
            head=node;
        }
        size++;
    }

1.2 链表中间位置插入addIndex(int index,int val)

  • 首先判断索引的合法性（index<0 || index>size）非法
  • 若index=0为头部插入
  • index在中间位置（核心是找到插入位置的前驱节点）
    例如将7插入到index为1的位置，先让7指向插入位置，再让它的前驱节点指向它。
    前驱节点怎样找？
    用for循环遍历找到prev位置在这里插入图片描述
    public void addIndex(int index,int val){
        // 判断合法性
        if (index<0 || index>size){
            System.out.println("error");
            return;
        }
        if (index==0){
            addFirst(val);
            return;
        }
        // 插入元素，先创建
        Node node =new Node(val);
        // 找插入位置的前驱节点,先让前驱节点为头节点，在遍历向后走index-1步
        Node prev=head;
        for (int i = 0; i < index-1; i++) {
            prev=prev.next;
        }
        node.next=prev.next;
        prev.next=node;
        size++;
    }

2.链表的查找

  • get(int index)返回index位置的元素值
  • contains(int value) 查询值为value的元素在单链表中是否存在，存在返回true，否则返回false;

2.1 get(int index)

先判断index合法性（index<0 || index>=size）非法，此处index不能=size，因为size位置无元素

public int get(int index){
        // 合法性校验  rangecheck(index)为index合法性检测的方法
        if (rangecheck(index)){
            Node node=head;
            // 规定了node节点走了多少步
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            return node.val;
        }else{
            System.out.println("error");
            return -1;
        }
    }

2.2 contains(int value)

 public boolean contains(int val){
      Node temp=head;
      while(temp!=null){
          if (temp.val==val){
              return true;
          }
          temp=temp.next;
      }
      return false;
    }

3.链表的修改set(int index,int newval)

    // 修改链表index位置的元素值，返回修改前的值
    public int set(int index,int newval){
        if (rangecheck(index)){
            Node node=head;
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            int oldval=node.val;
            node.val=newval;
            return oldval;
        }else{
            System.out.println("error");
            return -1;
        }
    }

4.链表的删除

4.1 利用索引删除链表元素

例如删除3这个节点，先让3的前驱节点指向3的下一个节点，再让3指向5的线断掉
在这里插入图片描述

    public void removeindex(int index){
        if (rangecheck(index)){
            // 删除头节点
            if (index==0){
                Node temp=head;
                head=head.next;
                temp.next=null;
                size--;
            }else{
                // index是中间位置
                // 找到待删除节点的前驱节点
                Node prev =head;
                for (int i = 0; i < index-1; i++) {
                    prev=prev.next;
                }
                // 待删除节点
                Node cur=prev.next;
                prev.next=cur.next;
                cur.next=null;
                size--;
            }
        }
    }
    // 删除头部
    public void removeFirst(){
        removeindex(0);
    }
    //  // 删除尾部
    public void removeLast(){
        removeindex(size-1);
    }

4.2 利用元素值删除链表元素

removeValue(int value)
removeValueAll(int value)

 public void removeValueOnce(int val){
        // 遍历链表找到值为val的节点
        // 找到后删除
        if (head!=null&&head.val==val){
            // 头节点为待删除的节点
            Node temp=head;
            head=head.next;
            temp.next=null;
            size--;
        }else{
            // 头节点不是待删除的节点，此时需要找到待删除节点的前驱节点
           Node prev=head;
           // 判断前驱节点的下一个节点值是否是val
            while(prev.next!=null){
                if(prev.next.val==val){
                    Node cur=prev.next;
                    // cur是待删除的节点
                    prev.next=cur.next;
                    cur.next=null;
                    size--;
                    return;
                }
                prev=prev.next;
            }
        }
    }

 public void removeValueAll(int val){
   // 头节点就是待删除的节点
        while (head!=null&&head.val==val){
            head=head.next;
            size--;
        }
        if(head==null){
            // 链表中全是待删除的元素
            return;
        }else{
            // head不是待删除的节点
            Node prev=head;
            while(prev.next!=null){
                if (prev.next.val==val){
                    Node cur=prev.next;
                    prev.next=cur.next;
                    cur.next=null;
                    size--;
                }else{
                    prev=prev.next;
                }
            }
        }
    }

5 完整代码

package seqlist;
// 火车类，里面包含多个车厢和第一个车厢的地址
public class SingleLinkedList {
    // 车厢的节点个数
    private int size;
    // 火车头节点
    private Node head;
    // 火车头部添加元素
    public void addFirst(int val){
        // 先创建需要挂载的车厢节点
        Node node =new Node(val);
        // 判断火车头部是否为空
        if (head==null){
            head=node;
        }
        // 火车有节点，要将当前新车厢挂载到火车头节点上
        else{
            // 新车厢指向head头节点
            node.next=head;
            // 新的头节点再指向之前的头节点
            head=node;
        }
        size++;
    }
    public void addIndex(int index,int val){
        // 判断合法性
        if (index<0 || index>size){
            System.out.println("error");
            return;
        }
        if (index==0){
            addFirst(val);
            return;
        }
        // 插入元素，先创建
        Node node =new Node(val);
        // 找插入位置的前驱节点,先让前驱节点为头节点，在遍历向后走index-1步
        Node prev=head;
        for (int i = 0; i < index-1; i++) {
            prev=prev.next;
        }
        node.next=prev.next;
        prev.next=node;
        size++;
    }
    public void addLast(int val){
        addIndex(size,val);
    }
    public int get(int index){
        // 合法性校验
        if (rangecheck(index)){
            Node node=head;
            // 规定了node节点走了多少步
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            return node.val;
        }else{
            System.out.println("error");
            return -1;
        }
    }

    public boolean contains(int val){
      Node temp=head;
      while(temp!=null){
          if (temp.val==val){
              return true;
          }
          temp=temp.next;
      }
      return false;
    }
    // 修改链表index位置的元素值，返回修改前的值
    public int set(int index,int newval){
        if (rangecheck(index)){
            Node node=head;
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            int oldval=node.val;
            node.val=newval;
            return oldval;
        }else{
            System.out.println("error");
            return -1;
        }
    }
// 利用索引删除链表元素
    public void removeindex(int index){
        if (rangecheck(index)){
            // 删除头节点
            if (index==0){
                Node temp=head;
                head=head.next;
                temp.next=null;
                size--;
            }else{
                // index是中间位置
                // 找到待删除节点的前驱节点
                Node prev =head;
                for (int i = 0; i < index-1; i++) {
                    prev=prev.next;
                }
                // 待删除节点
                Node cur=prev.next;
                prev.next=cur.next;
                cur.next=null;
                size--;
            }
        }
    }
    // 删除头部
    public void removeFirst(){
        removeindex(0);
    }
    //  // 删除尾部
    public void removeLast(){
        removeindex(size-1);
    }
    //
    public void removeValueOnce(int val){
        // 遍历链表找到值为val的节点
        // 找到后删除
        if (head!=null&&head.val==val){
            // 头节点为待删除的节点
            Node temp=head;
            head=head.next;
            temp.next=null;
            size--;
        }else{
            // 头节点不是待删除的节点，此时需要找到待删除节点的前驱节点
           Node prev=head;
           // 判断前驱节点的下一个节点值是否是val
            while(prev.next!=null){
                if(prev.next.val==val){
                    Node cur=prev.next;
                    // cur是待删除的节点
                    prev.next=cur.next;
                    cur.next=null;
                    size--;
                    return;
                }
                prev=prev.next;
            }
        }
    }
    public void removeValueAll(int val){
   // 头节点就是待删除的节点
        while (head!=null&&head.val==val){
            head=head.next;
            size--;
        }
        if(head==null){
            // 链表中全是待删除的元素
            return;
        }else{
            // head不是待删除的节点
            Node prev=head;
            while(prev.next!=null){
                if (prev.next.val==val){
                    Node cur=prev.next;
                    prev.next=cur.next;
                    cur.next=null;
                    size--;
                }else{
                    prev=prev.next;
                }
            }
        }
    }
    // 索引合法性检测,改，查，删除
    private boolean rangecheck(int index){
        // 判断合法性
        if (index<0 || index>=size){
            return false;
        }
        else{
            return true;
        }
    }

    public String toString(){
        String ret="";
        // 遍历火车类，从头走到尾
        // node暂时存放当前头节点，相当于临时变量
        Node node=head;
        while(node!=null){
            ret += node.val;
            ret += "->";
            // node走向下一个节点
            node =node.next;
        }
        ret += "NULL";
        return ret;

    }
}
// 车厢类
class Node{
    // 存储每个车厢存放的数据
    int val;
    //下个车厢的节点
    Node next;

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


package seqlist;

public class Test {
    public static void main(String[] args) {
        // 使用火车类，创建火车类对象
        SingleLinkedList singleLinkedList=new SingleLinkedList();
        singleLinkedList.addFirst(1);
        singleLinkedList.addFirst(3);
        singleLinkedList.addFirst(5);
        //5->3->1->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.addIndex(1,10);
        //5->10->3->1->NULL
        System.out.println(singleLinkedList);
        //3
        System.out.println(singleLinkedList.get(2));
        // false
        System.out.println(singleLinkedList.contains(2));
        // true
        System.out.println(singleLinkedList.contains(10));
        //10
        System.out.println(singleLinkedList.set(1,7));
        //5->7->3->1->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.removeindex(1);
        //5->3->1->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.removeFirst();
        //3->1->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.removeLast();
        //3->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.addFirst(3);
        singleLinkedList.addFirst(5);
        //5->3->3->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.removeValueOnce(3);
        //5->3->NULL
        System.out.println(singleLinkedList);
        singleLinkedList.addFirst(3);
        singleLinkedList.addFirst(3);
        singleLinkedList.addFirst(3);
        singleLinkedList.removeValueAll(3);
        //5->NULL
        System.out.println(singleLinkedList);
    }
}
HH~LL
关注
专栏目录
【Java实现链表的增删改查】
leach
03-20 749
数据结构之链表 1.数据的增加分为头插和尾插和中间插入： 头插：令每一个进来的新节点的next为指向头，然后改头为新节点 尾插：令Current+1的节点为新节点 中间插入：找到你想插入的位置的前一个节点，让这个新结点的next->前一个节点的后一个节点，再让前一个节点指向新节点 public void add(int data,int index) { if (head == null) { head = new Node(data, null);
Java单链表增删改查的实现
08-15
Java实现单链表的增删改查以及选择、冒泡、反转排序等功能的实现！
java-链表的增删改查
H_xxxxd的博客
03-15 1391
java对链表的操作
java 链表的增删改查
lcb5203344的博客
06-27 99
个人记录方法用
JAVA 实现链表增删改查
LZ111566的博客
05-18 271
链表 数据分散的存储在物理空间中，通过一根线保持他们之间的逻辑关系，这种存储结构称为链式存储结构。 实际上，就是每一个结点存放一个元素和一个指向下一个结点的引用（c语言里叫做指针） 实现类 public class Main { public static void main(String[] args) { /** * 链表 */ AbstractList<String> list = new Link.
数据结构之链表增删改查实现方式(Java)
斗鹰的技术专栏
08-15 867
链表 链表是一种在物理上非连续、非顺序的数据结构，由若干个节点(node)所组成。 单向链表的每一个节点又包含两部分，一部分是存放数据的变量data，另一部分是指向下一个节点的指针next。 链表的第一个节点被称为头节点，最后一个节点被称为尾节点，尾节点的next指针指向空。链表是通过其中的next属性来确定下一个节点，来顺序存储。如图： 下面主要说一下单链表的增删改查的实现方式以及...
java实现链表增删改查
01-07
用java实现链表增删改查
java实现单链表增删改查的实例代码详解
10-16
以上就是对单链表进行增删改查操作的详细实现。通过这些方法，我们可以对链表进行各种操作，实现对链表数据的灵活管理和处理。在实际应用中，单链表是一种非常重要的数据结构，它被广泛应用于各种算法和程序设计中。...
Java描述数据结构学习之链表的增删改查详解
08-27
Java链表数据结构学习之增删改查详解 本文将从链表的基本概念、链表的定义、链表的增删改查操作等方面对Java描述数据结构学习之链表的增删改查进行详细的解释。 链表是一种常见的基础数据结构，它是一种线性表，但...
双向链表的增删改查（java实现）
New soul
08-10 785
创建节点对象 // 定义节点，每个heroNode对象都是一个节点 class HeroNode2 { int no; String name; String nickName; HeroNode2 next; HeroNode2 pre; public HeroNode2(int no, String name, String nickName) { this.no = no; this.nickName = nick
Java单链表的增删改查
m0_59540171的博客
04-20 1673
单链表是一种常见的数据结构，它由一个节点序列组成，每个节点只包含一个指向下一个节点的指针。相比于其他链表结构，单链表的节点体积较小，因此常用于存储小型数据集，如栈、队列和链表等。单链表的节点结构通常包含一个数据域和一个指向下一个节点的指针。节点之间的链接是通过指针实现的，也就是说，第一个节点只有一个指向它的指针，而最后一个节点则只有一个指向第一个节点的指针。单链表的操作比较简单，主要包括添加节点、删除节点和遍历节点等。在添加节点时，只需要在末尾添加一个新节点即可。
JAVA实现数据结构的链表的增删改查
一曲无痕奈何
09-29 401
package com.Arry.Struct; // 导入文件包 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sr = new Scanner(System.in); Array&lt;Integer&g...
Java实现链表的增查改删（单链表、带头单链表、双向链表）
XHT117的博客
05-02 2176
java链表万字详解，链表的增查改删 单链表、带头单链表、双向链表 1.1 单向链表 1.2 单链表增删查改 2.1 带头单链表 2.2 带头单链表增删查改
Java实现单链表的增删改查
XDarker的博客
10-13 370
package algorithm.linkedlist; /** * @Created by XDarker * @Description Java实现单链表的增删改查 * @Date 2019/10/12 22:22 */ public class LinkedListDemo { public static void main(String[] args) { // ...
java数据结构之链表（增删改查等操作）
java编程学习_java基础教程_booyzhang的博客
05-06 441
在链表中，需要使用到递归算法 递归算法： 一种直接或间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。 递归实例： public class JiechengTest{ public static void main(String[] args){ //int result = jiecheng1(5); int re...
链表的增删改查Java代码实现
weixin_42041653的博客
02-21 364
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。 链表与数组之间的差别是： （1...
java 链表实现增删改查功能
于沛杰的博客
11-18 679
 我的代码： package y; import java.lang.Math; import java.util.*; public class ypj_LNode1 {  public static void main(String[] args) {   // TODO Auto-generated method stub   ypj_LNode1 L=new y
java实现单链表的增删改查
最新发布
Dream It Possible
01-27 493
单链表：单链表中的每个节点不仅包含储存的数据，还包含指向下一个节点的链接。
【java】实现链表的增删查（含泛型）
aaaayl的博客
05-05 258
链表是线性的数据结构，其在内存中是随机存储的。查找的时间复杂度为O(n),增删(不计入查找)的时间复杂度是O(1)。 1、使用泛型创建Node.class public class Node <E> { E data; Node<E> next; public Node(E data){ this.data=data; }...
Java链表数据结构详解：增删改查与实现
本文主要探讨了Java中如何理解和实现链表数据结构，并详细讲解了链表的增删改查操作。链表作为一种基础数据结构，虽然不像数组那样在内存中顺序存储，但它的特点是通过节点之间的引用关系连接，这使得在插入和删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值