【数据结构】Java单链表

节点类

public class Node {

    // 数据域
    public int data;

    // 指针域，指向下一个节点
    public Node next;

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

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                '}';
    }
}

链表接口类

public interface ILinkedList {

    void addNode(Node node);

    void addNodeByPos(int index, Node node);

    void deleteNodeByPos(int index);

    int length();

    void printAll();

}

链表实现类

public class LinkedList implements ILinkedList {

    public Node head; //头节点

    public LinkedList() {
        this.head = null;
    }

    @Override
    public void addNode(Node node) {
        if (head == null) {
            head = node;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
    }

    @Override
    public void addNodeByPos(int index, Node node) {
        if (!isPositionIndex(index)) {
            System.out.println("插入位置非法");
            return;
        }
        if (index == 0) {
            node.next = head;
            head = node;
            return;
        }
        Node temp = head;
        int moveLength = 0;
        while (moveLength != index - 1) {
            temp = temp.next;
            moveLength++;
        }
        node.next = temp.next;
        temp.next = node;
    }

    @Override
    public void deleteNodeByPos(int index) {
        if (!isPositionIndex(index)) {
            System.out.println("删除位置非法");
            return;
        }
        if (index == 0) {
            head = head.next;
            return;
        }
        Node temp = head;
        int moveLength = 0;
        while (moveLength != index - 1) {
            temp = temp.next;
            moveLength++;
        }
        temp.next = temp.next.next;
    }

    @Override
    public int length() {
        int length = 0;
        Node temp = head;
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

    @Override
    public void printAll() {
        Node temp = head;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= length();
    }

    /**
     * 循环逆序
     */
    public void reverse() {
        Node newHead = doReverse(head);
        head = newHead;
    }

    // 递归逆序
    public void reverse2() {
        Node newHead = doReverse2(head);
        head = newHead;
    }

    /**
     * 循环，从头节点开始往后反转
     *
     * @param node
     * @return
     */
    private Node doReverse(Node node) {
        if (node == null || node.next == null) {
            return node;
        }
        Node prev = null;
        Node next = null;
        while (head != null) {
            next = head.next;
            head.next = prev;
            prev = head;
            head = next;
        }
        // 最后一个节点反转后，prev正好指向新的头节点
        return prev;
    }


    /**
     * 递归，先找到尾节点，再往前反转
     *
     * @param node
     * @return
     */
    private Node doReverse2(Node node) {
        if (node == null || node.next == null) {
            // 基线条件，如果是最后一个节点直接返回，作为最终的返回结果
            return node;
        }
        Node newHead = doReverse(node.next);
        node.next.next = node; //后一个节点指向当前节点
        node.next = null; //当前节点不再指向后一个节点
        return newHead;
    }

}

Main类

public class Main {

    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        Node node01 = new Node(1);
        Node node02 = new Node(2);
        Node node03 = new Node(3);
        Node node04 = new Node(4);
        linkedList.addNode(node01);
        linkedList.addNode(node02);
        linkedList.addNode(node03);
        linkedList.addNode(node04);
        linkedList.printAll();
        System.out.println("");

        Node node05 = new Node(5);
        linkedList.addNodeByPos(4, node05);
        linkedList.printAll();
        System.out.println("");


        linkedList.reverse();
        linkedList.reverse2();
        linkedList.printAll();
    }
}

参考文章

【数据结构】Java单链表的逆序

Java实现链表