Java实现单链表的插入、删除、计算链表的长度和输出链表

首先定义单链表（以下统称为链表）：

链表有两部分：数据和指向下一个节点的指针。

这里引用书中的一张图片：

一般是知道头指针，然后根据头指针做插入、删除、反转、排序、输出等操作。

使用Java实现链表的结构如下：

/**
 * 链表的结构
 * @author haoge
 */
public class Node {
    //链表节点的数据
    int data;
    //链表指向的下一个节点的指针
    Node next = null;

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

链表的操作部分：

/**
 * 链表的插入、删除、计算长度和打印链表
 * @author haoge
 *
 */
public class MyNode {

    public static void main(String[] args) {
        MyNode mNode = new MyNode();
        //链表的头指针
        Node head = null;

        //新增节点,第一次新增时需要返回头指针，用于定位链表
        head = mNode.insertNode(2, head);
        mNode.insertNode(5, head);
        mNode.insertNode(4, head);
        mNode.insertNode(3, head);
        mNode.insertNode(1, head);

        //链表的长度
        System.out.println("链表的长度为：" + mNode.length(head));

        //输出节点
        mNode.printList(head);

        //删除节点
        if ((head = mNode.deleteNode(2, head)) != null) {
            System.out.println("删除索引为2的节点后：");
            mNode.printList(head);
        } else {
            System.out.println("删除失败！");
            mNode.printList(head);
        }

        //删除头结点测试
        if ((head = mNode.deleteNode(1, head)) != null) {
            System.out.println("删除头节点后：");
            mNode.printList(head);
        } else {
            System.out.println("删除失败！");
            mNode.printList(head);
        }
    }

    /**
     * 新增节点
     * @param data
     */
    public Node insertNode(int data, Node head) {
        Node node = new Node(data);
        if (head == null) {
            head = node;
            return head;
        }
        Node curNode = head;
        //循环找到当前链表的尾节点
        while (curNode.next != null) {
            curNode = curNode.next;
        }
        //尾节点的指针指向新增加的节点
        curNode.next = node;
        return head;
    }

    /**
     * 链表的长度
     * @return
     */
    public int length(Node head) {
        Node curNode = head;
        int length = 0;
        while (curNode != null) {
            curNode = curNode.next;
            length ++;
        }
        return length;
    }

    /**
     * 删除节点
     */
    public Node deleteNode(int index, Node head) {
        //删除的节点的索引小于1或者大于链表的长度，直接返回false
        if (index < 1 || index > length(head)) {
            return null;
        }
        //删除头结点
        if (index == 1) {
            head = head.next;
            return head;
        }
        //从头结点的下一个节点开始遍历
        Node curNode = head.next;
        //记录当前循环的节点的上一个节点用于删除当前节点
        Node preNode = head;
        int i = 2;
        while (curNode != null) {
            if (i == index) {
                //前一个节点的next指向当前节点的下一个节点，即删除当前节点
                preNode.next = curNode.next;
                break;
            } else {
                preNode = curNode;
                curNode = curNode.next;
            }
        }

        return head;
    }

    /**
     * 打印链表
     */
    public void printList(Node head) {
        Node curNode = head;
        //循环遍历到尾节点
        while (curNode != null) {
            System.out.print(curNode.data + "  ");
            curNode = curNode.next;
        }
        System.out.println();
    }
}

输出结果：

链表的长度为：5
2  5  4  3  1  
删除索引为2的节点后：
2  4  3  1  
删除头节点后：
4  3  1