Java实现单链表以及原地逆置

节点构造方法

class Node<E>{
    E value;
    Node next;
    Node(E  val,Node  next){
        this.value = val;
        this.next = next;
    }
}

链表类

class LinkedList<B>{

    //头结点
    private Node<B> first;
    //尾结点
    private Node<B> tail;
    //数据节点数
    private static int nodeSize = 0;
    //构造方法
    public LinkedList(){};

    /**
     * 头插法增加元素
     */
    public void linkFirst(B e) {
        //暂存第一个节点元素
        final Node<B> f = first;
        //处理当前元素
        final Node<B> newNode = new Node<>(e, f);
        //第一个元素为当前元素
        first = newNode;
        if (f == null)
            tail = newNode;
        nodeSize++;
    }

    /**
     * 尾插法增加元素
     */
    public void linkLast(B e) {
        //暂存尾结点
        final Node<B> l = tail;
        //创建新节点
        final Node<B> newNode = new Node<>(e, null);
        //尾结点指向新节点
        tail = newNode;
        //若是第一个节点，则头结点指向第一个节点
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        nodeSize++;
    }

    public static void printNodeNum(){
        System.out.println("当前链表节点总数为："+ nodeSize);
    }

    //顺序遍历单链表
    public static void traverse(LinkedList list){
        Node p = list.first;
        while(null != p){
            if(null != p.next){
                System.out.print(p.value + "->");
            }else {
                System.out.print(p.value);
            }
            p = p.next;
        }
        System.out.println();
    }

    //原地逆置单链表
    public static void reverse(LinkedList list){
        //收尾指针第一个节点
        Node tail = list.first;
        //工作指针pre p
        Node pre = list.first;
        Node p = pre.next;
        while (null != p){
            Node next = p.next;
            p.next = pre;
            pre = p;
            p = next;
        }
        //更新头指针
        list.first = pre;
        //尾指针指针域置空，防止出现环
        tail.next = null;
        traverse(list);

    }
}

测试用例方法

public static void main(String[] args) {

        LinkedList linkedList = new LinkedList();
        linkedList.linkFirst(1);
        linkedList.linkFirst(3);
        linkedList.linkFirst(5);
        linkedList.linkFirst(7);
        linkedList.linkFirst(9);
        System.out.println("头插法输出：");
        LinkedList.traverse(linkedList);

        LinkedList linkedList2 = new LinkedList();
        linkedList2.linkLast(1);
        linkedList2.linkLast(3);
        linkedList2.linkLast(5);
        linkedList2.linkLast(7);
        linkedList2.linkLast(9);
        System.out.println("尾插法输出：");
        LinkedList.traverse(linkedList2);
        LinkedList.reverse(linkedList2);

    }
输出：
头插法输出：
9->7->5->3->1
尾插法输出：
1->3->5->7->9
9->7->5->3->1