【Java基础】 建立一个单链表(增删查改)

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

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

代码如下:

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{
            node.next=head;
            head=node;
        }
        size++;
    }
    public void addIndex(int index,int val){
        //1.合法性
        if(index<0||index>size){
            System.out.println("add index illegal!");
            return;
        }
        //头插
        if(index==0){
            addFirst(val);
            return;
        }
        Node node=new Node(val);
        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 getIndexValue(int index){
        if(rangeCheck(index)){
            Node node=head;
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            return node.val;
        }else{
            System.out.println("get index illegal!");
            return -1;
        }
    }
    //改
    public int set(int index,int val){
        if(rangeCheck(index)){
            Node node=head;
            for (int i = 0; i < index; i++) {
                node=node.next;
            }
            int oldVal=node.val;
            node.val=val;
            return oldVal;
        }else{
            System.out.println("set index illegal!");
            return -1;
        }
    }
    //删
    //根据索引删除元素
    public void removeIndex(int index){
        if(rangeCheck(index)){
            //删除头节点
            if(index==0){
                Node temp=head;
                head=head.next;
                temp.next=null;
                size--;
            }else {
                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--;
            }
        }else {
            System.out.println("remove index illegal!");
        }
    }
    public void removeFirst(){
        removeIndex(0);
    }
    public void removeLast(){
        removeIndex(size-1);
    }
    //删除某个元素一次
    public void removeValueOnce(int val){
        if(head!=null&&head.val==val){
            Node temp=head;
            head=head.next;
            temp.next=null;
            size--;
        }else{
            Node prev=head;
            while (prev.next!=null){
                if(prev.val==val){
                    Node cur=prev.next;
                    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{
            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;
                    }
            }
        }
    }
    //判断元素是否在链表中存在
    public boolean isFind(int val){
        Node temp=head;
        while (temp.next!=null){
            if(temp.val==val){
                return true;
            }
            temp=temp.next;
        }
        return false;
    }
    //判断Index的合法性
    private boolean rangeCheck(int index){
        if(index<0||index>=size){
            return false;
        }
        return true;
    }
    //输出
    public String toString(){
        String ret="";
        Node node=head;
        while(node!=null){
            ret+=node.val;
            ret+="->";
            node=node.next;
        }
        ret+="null";
        return ret;
    }
}
class Node{
    int val;
    Node next;
    public Node(int val){
        this.val=val;
    }
}

image.gif

引用方法如下:

package seqlist;
public class Test {
    public static void main(String[] args) {
        SingLeLinkedList singLeLinkedList=new SingLeLinkedList();
        singLeLinkedList.addFirst(1);
        singLeLinkedList.addLast(3);
        singLeLinkedList.addLast(2);
        singLeLinkedList.addLast(5);
        singLeLinkedList.addLast(5);
        singLeLinkedList.addLast(6);
        singLeLinkedList.addIndex(1,2);
        //1->2->3->2->5->5->6->null
        System.out.println(singLeLinkedList);
        //2
        System.out.println(singLeLinkedList.getIndexValue(1));
        //true
        System.out.println(singLeLinkedList.isFind(1));
        singLeLinkedList.removeFirst();
        singLeLinkedList.removeLast();
        singLeLinkedList.removeIndex(1);
        //2->2->5->5->null
        System.out.println(singLeLinkedList);
        singLeLinkedList.removeValueOnce(5);
        singLeLinkedList.removeValueAll(2);
        //5->null
        System.out.println(singLeLinkedList);
    }
}

image.gif

依据以上输入结果如下:

image.gif编辑


相关文章
|
缓存 Java 程序员
Java建立在C++上的优势
Java建立在C++上的优势
73 0
|
3月前
|
存储 Java
java数据结构,线性表链式存储(单链表)的实现
文章讲解了单链表的基本概念和Java实现,包括头指针、尾节点和节点结构。提供了实现代码,包括数据结构、接口定义和具体实现类。通过测试代码演示了单链表的基本操作,如添加、删除、更新和查找元素,并总结了操作的时间复杂度。
java数据结构,线性表链式存储(单链表)的实现
|
6月前
|
网络协议 Java API
【Java】Java Socket编程:建立网络连接的基础
【Java】Java Socket编程:建立网络连接的基础
99 1
|
5月前
|
Java Redis 数据安全/隐私保护
Redis13的Java客户端-Jedis快速入门,建立连接的写法,ip地址,设置密码密码,选择库的写法
Redis13的Java客户端-Jedis快速入门,建立连接的写法,ip地址,设置密码密码,选择库的写法
|
6月前
|
网络协议 Java
java建立非阻塞TCP链接
java建立非阻塞TCP链接
|
7月前
|
消息中间件 Java RocketMQ
MQ产品使用合集之在同一个 Java 进程内建立三个消费对象并设置三个消费者组订阅同一主题和标签的情况下,是否会发生其中一个消费者组无法接收到消息的现象
消息队列(MQ)是一种用于异步通信和解耦的应用程序间消息传递的服务,广泛应用于分布式系统中。针对不同的MQ产品,如阿里云的RocketMQ、RabbitMQ等,它们在实现上述场景时可能会有不同的特性和优势,比如RocketMQ强调高吞吐量、低延迟和高可用性,适合大规模分布式系统;而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集,这些场景涵盖了多种行业和业务需求。
135 1
|
7月前
|
Java
DAY-1 | Java数据结构之链表:删除无头单链表中等于给定值 val 的所有节点
力扣203题解:使用时间复杂度为O(n)的思路删除链表中所有值为key的元素。引入辅助指针pre,记录cur的前一个节点,遍历链表时,若cur.val!=key,pre和cur同时前进;若cur.val==key,则pre.next=cur.next,cur继续前进,确保pre不急于跟随以处理连续相同值的情况。遍历结束后,处理头节点可能需要删除的特殊情况。
51 0
|
Rust 自然语言处理 Java
单链表的多语言表达:C++、Java、Python、Go、Rust
单链表是一种链式数据结构,由一个头节点和一些指向下一个节点的指针组成。每个节点包含一个数据元素和指向下一个节点的指针。头节点没有数据,只用于表示链表的开始位置。单链表相对于数组的优点是插入和删除元素时不需要移动其他元素,时间复杂度为O(1)。但是,在查找元素时,单链表比数组要慢,时间复杂度为O(n)。
16659 7
|
7月前
|
存储 Java
Java 实现单链表
Java 实现单链表
48 0
|
7月前
|
存储 Java
Java实现单链表
Java实现单链表
56 0