[数据结构]无头结点单链表JAVA

注1：仅做出简单的增删改查功能，对于重复的遍历可以自己做出响应的修改调用，部分未做出边界值的测试。

注2：对于头结点和头指针需弄清，避免在算法的撰写上做出不必要的错误

注3：对于链表的删除，是否在内存中是否仍存在需要理解，避免在C/C++等算法时内存溢出问题。

接口：

/**
 * @author: hj
 * @version:1.0
 * @className: ListLink
 * @Describe:
 * @Date: Created in 2024/3/11
 */
public interface ListLink {
    void InsertHeadNode(int num);   //头插
    void InsertCurNode(int num);    //尾插
    void InsertIndexNode(int index, int num);   //指定位置插入
    int SearchIndexNode(int index);  //输出指定位置节点值
    void PrintNode();   //输出所有节点
    boolean DelIndexNode(int index);    //删除指定位置节点
    void DelLinkList();     //清空所有链表
    void Clear();   //防止内存溢出的清除方法
    boolean ModifyNode(int index, int num);    //修改指定节点的数值；
    int Length();
}

实现类：

/**
 * @author: hj
 * @version:1.0
 * @className: ListNode
 * @Describe:  未使用头结点单链表
 * @Date: Created in 2024/3/11
 */
public class ListNode implements ListLink {

    private int val;    //数据域
    private ListNode next;  //指针域
    private int size = 0;   //记录链表长度
    //头指针永远指向链表的第一个元素：头结点【声明了头结点则指向头结点】/首元结点
    //头指针只声明，没有开辟空间
    //头结点声明并开辟了空间
    private ListNode headNode;  //头指针

    public ListNode(){}

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

    public ListNode(int val, ListNode next){
        this.val = val;
        this.next = next;
    }

    /**
     * @Description 头插法
     * @author hj
     * @date 2024/3/11 15:15
     * * @param null
     *
     */
    @Override
    public void InsertHeadNode(int num) {
        //创建新的节点并开辟
        ListNode newNode = new ListNode(num);
        //若为空链表则直接插入头节点后
        //若不为空链表则将创建的新结点的指针域指向headNode的下一个结点
        //同时更新headNode的指针域，使其指向新结点
        if (headNode == null){
            headNode = newNode;
        }else {
            ListNode tempHeadNode = headNode;
            newNode.next = tempHeadNode;
            headNode = newNode;
        }
        this.size++;
        //System.out.println("success!");
    }

    /**
     * @Description 尾插法
     * @author hj
     * @date 2024/3/11 17:20
     * * @param null
     *
     */
    @Override
    public void InsertCurNode(int num) {
        //创建新结点
        ListNode newNode = new ListNode(num);
        if (headNode == null){
            headNode = newNode;
        }else {
            ListNode tempHeadNode = headNode;
            while (tempHeadNode.next != null){
                tempHeadNode = tempHeadNode.next;
            }
            tempHeadNode.next = newNode;
        }
        this.size++;
    }

    /**
     * @Description 指定位置后插入
     * @author hj
     * @date 2024/3/11 17:25
     * * @param null
     *
     */
    @Override
    public void InsertIndexNode(int index, int num) {
        //越界则退出
        if (index < 1 || index > this.size){
            System.out.println("Crossed!");
            return;
        };

        //创建新结点，并在尾处插入
        ListNode newNode = new ListNode(num,null);
        ListNode tempIndexNode = headNode;
        int i = 1;
        while ( i != index){
            tempIndexNode = tempIndexNode.next;
            i++;
        }
        newNode.next = tempIndexNode.next;
        tempIndexNode.next = newNode;
        this.size++;
        System.out.println("successfully insert!");
    }

    /**
     * @Description 输出指定位置结点数值
     * @author hj
     * @date 2024/3/11 17:29
     * * @param null
     *
     */
    @Override
    public int SearchIndexNode(int index) {
        //若越界则输出-1
        if (index < 1 || index > this.size) return -1;

        //遍历到指定位置，输出数值
        ListNode tempIndexNode = headNode;
        int i = 1;
        while (i != index){
            tempIndexNode = tempIndexNode.next;
            i++;
        }
        return tempIndexNode.val;
    }

    /**
     * @Description 遍历
     * @author hj
     * @date 2024/3/11 15:15
     * * @param null
     *
     */
    @Override
    public void PrintNode() {
        ListNode tempIndexNode = headNode; //创建临时指针，用于当作遍历指针
        if (tempIndexNode == null) System.out.println("This is an empty List");
        while (tempIndexNode != null) {
            System.out.print(tempIndexNode.val +"\t");
            tempIndexNode = tempIndexNode.next;
        }
    }

    /**
     * @Description 删除指定结点
     * @author hj
     * @date 2024/3/11 15:15
     * * @param null
     *
     */
    @Override
    public boolean DelIndexNode(int index) {
        //删除失败，越界
        if (index < 1 || index > size) return false;
        //删除头结点
        if (index == 1){
            headNode = headNode.next;
            return true;
        }
        //删除头结点以外的
        ListNode preIndexNode = headNode;
        ListNode curIndexNode = headNode.next;
        int i = 2;
        while (curIndexNode != null){
            if (i == index) {
                preIndexNode.next= curIndexNode.next;
                this.size--;
                return  true;
            }
            preIndexNode = curIndexNode;
            curIndexNode = curIndexNode.next;
            i++;
        }
        return false;
    }

    /**
     * @Description 列表全清空[仅指针null，内存中实际存在原元素]
     * @author hj
     * @date 2024/3/11 15:16
     * * @param null
     *
     */
    @Override
    public void DelLinkList() {
        headNode = null;
        this.size = 0;
    }

    /**
     * @Description 更改结点数值
     * @author hj
     * @date 2024/3/11 17:32
     * * @param null
     *
     */
    @Override
    public boolean ModifyNode(int index, int num) {
        if (index > this.size || index < 1)  return false;

        ListNode indexNode = headNode;
        int j = 1;
        while (j != index){
            indexNode = indexNode.next;
            j++;
        }
        indexNode.val = num;
        return true;
    }

    @Override
    public int Length() {
        return this.size;
    }

    /**
     * @Description  从头结点开始挨个删除所有元素，避免内存溢出
     * @author hj
     * @date 2024/3/12 12:44
     * * @param null
     *
     */
    @Override
    public void Clear() {
        if (headNode.next != null){
            ListNode cur = this.headNode.next;
            this.headNode.next = null;
            this.headNode = cur;
        }
        //制空headNode
        headNode.next = null;
        this.headNode = null;
        this.size = 0;
        System.out.println(this.size);
    }
}

测试用例需要自己安排并进行输出。