Java链表基础操作

创建ListNode对象

import lombok.ToString;

/**
 * @Date 2021/12/23 19:28
 * Definition for singly-linked list.
 */

//@ToString
public class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

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

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

    /**
     * 为了测试方便查看 重写toString方法
     * @return
     */
    @Override
    public String toString() {
        return  val + "->" + next;
    }
}

插入，删除，替换，反转，操作

/**
 * @Date 2021/12/23 19:42
 */
public class reverseListOfferII024 {

    /**
     * 测试函数
     * @param args 
     */
    public static void main(String[] args) {

        //创建首个节点
        ListNode head = new ListNode(0);
        //声明一个变量用来在移动过程中指向
        ListNode nextNode;
        //指向首节点
        nextNode = head;

        //创建链表
        for (int i = 1; i < 5; i++) {
            //生成新节点
            ListNode node = new ListNode(i);
            //指向新节点
            nextNode.next = node;
            //将当前节点向后移
            nextNode = nextNode.next;
        }
        //重新复制让它指向首个节点
        nextNode = head;
        System.out.println(nextNode.toString());
        //测试插入节点
        System.out.println(insertNode(nextNode).toString());
        //测试删除节点
        System.out.println(delNode(nextNode).toString());
        //测试替换节点
        System.out.println(replaceNode(nextNode).toString());
        //测试反转
        System.out.println(reverseList(nextNode).toString());
    }

    /**
     * 插入节点
     *
     * @param head
     * @return ListNode
     */
    private static ListNode insertNode(ListNode head) {
        ListNode curr = head;
        while (curr != null) {
            if (curr.val == 3) {
                ListNode newNode = new ListNode(99);
                ListNode node = curr.next;
                curr.next = newNode;
                newNode.next = node;
            }
            curr = curr.next;
        }
        return head;
    }

    /**
     * 删除节点
     *
     * @param head
     * @return ListNode
     */
    private static ListNode delNode(ListNode head) {
        ListNode curr = head;
        //删除的是节点值为3的上一个节点
        while (curr != null) {
            if (curr.val == 3) {
                //将要删除的节点后一个节点保存下来
                ListNode node = curr.next.next;
                //将删除节点的上一个节点指向 删除节点的下一个节点
                curr.next = node;
            }
            curr = curr.next;
        }
        return head;
    }

    /**
     * 替换节点
     *
     * @param head
     * @return ListNode
     */
    private static ListNode replaceNode(ListNode head) {
        ListNode curr = head;
        while (curr != null){
            if(curr.val == 3){
                //要替换的新节点
                ListNode newNode = new ListNode(88);
                //保留要替换掉的节点的下一个节点
                ListNode node = curr.next.next;
                //将替换掉的节点上一个节点指向新节点
                curr.next = newNode;
                //将新节点指向替换掉的节点的下一个节点
                newNode.next = node;
            }
            curr = curr.next;
        }
        return head;
    }
    /**
     * 反转列表
     * @param head 
     * @return ListNode
     */
    public static ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode temp = curr.next;
            curr.next = pre;
            pre = curr;
            curr = temp;
        }
        return pre;
    }
}

//运行结果
0->1->2->3->4->null
0->1->2->3->99->4->null
0->1->2->3->4->null
0->1->2->3->88->null
88->3->2->1->0->null