【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编辑


相关文章
|
7月前
|
缓存 Java 程序员
Java建立在C++上的优势
Java建立在C++上的优势
41 0
|
2月前
|
存储 Java
Java实现单链表
Java实现单链表
19 0
|
3月前
|
Java C++
单链表(Java每日一题)
单链表(Java每日一题)
29 0
|
8月前
|
Rust 自然语言处理 Java
单链表的多语言表达:C++、Java、Python、Go、Rust
单链表是一种链式数据结构,由一个头节点和一些指向下一个节点的指针组成。每个节点包含一个数据元素和指向下一个节点的指针。头节点没有数据,只用于表示链表的开始位置。单链表相对于数组的优点是插入和删除元素时不需要移动其他元素,时间复杂度为O(1)。但是,在查找元素时,单链表比数组要慢,时间复杂度为O(n)。
16640 7
|
7月前
|
存储 Java
图解Java数据结构之单链表
图解Java数据结构之单链表
|
7月前
|
Java Android开发
eclipse建立Java项目
eclipse建立Java项目
72 0
|
9月前
|
Java
java数据结构21:按大小顺序建立单链表并按要求删除节点
输入的每一行是姓名和年龄。读入每个人的信息,按年龄从小到大建立一个单链表。 按示例格式输出这个单链表。 删除链表中所有年龄是偶数的节 点,按示例格式输出剩下的所有节点。 要求:必须删除节点,不能只是跳过节点不输出。
46 0
|
10月前
|
存储 算法 Java
Java数据结构与算法分析(三)链表(单链表、双链表、环形链表)
通过前篇文章《[数组](https://blog.csdn.net/gozhuyinglong/article/details/109702860)》了解到数组的存储结构是一块连续的内存,插入和删除元素时其每个部分都有可能整体移动。为了避免这样的线性开销,我们需要保证数据可以不连续存储。本篇介绍另一种数据结构:链表。
174 0
|
10月前
|
存储 Java
一篇文章入门单链表+刷题实践【java实现+详细注释】
一篇文章入门单链表+刷题实践【java实现+详细注释】
10649 2