java模拟单向链表

package transferlinked;

import java.util.Stack;

/**
 * 单向链表
 * <p>
 * Version    1.0.0
 *
 * @author zhouyuyou
 * <p>
 * Date          2020/05/06 10:42
 */
public class TestSingleLinkedList<E> {

    /**
     * 链表节点
     * @param <E>
     */
    private static class Node<E>{
        /**
         * 数据域
         */
        E data;
        /**
         * 下一个节点
         */
        Node<E> next;

        public Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }

    /**
     *  头节点
     */
    private Node<E> headNode;
    /**
     *  头节点
     */
    private Node<E> tailNode;
    /**
     * 长度
     */
    private int size = 0;

    /**
     * 向链表末尾添加元素
     * @param e
     * @return void
     * @author zhouyuyou
     * @date 2020/05/06 11:06
     */
    public void addLast(E e){
        final Node<E> l = tailNode;
        final Node<E> newCode = new Node<>(e,null);
        tailNode = newCode;
        if(null == headNode){
            headNode = newCode;
        }else {
            l.next = newCode;
        }
        size++;
    }

    /**
     * 添加元素
     * @param e
     * @return boolean
     * @author zhouyuyou
     * @date 2020/05/06 11:22
     */
    public boolean add(E e){
       addLast(e);
       return true;
    }

    /**
     * 添加
     * @param index
     * @param e
     */
    public void add(int index,E e){
        //检查索引是否超过链表长度
        if(index == size){
            addLast(e);
        }else {
            //查询index的位置的前一节点
            Node<E> node = node(index-1);
            node.next = new Node<>(e,node.next);
            size++;
        }
    }

    Node<E> node(int index){
        Node<E> x = headNode;
        for(int i = 0;i< index ;i++){
            x = x.next;
        }
        return x;
    }

    /**
     * 索引查询
     * @param index
     * @return
     */
    public E get(int index) {
        return node(index).data;
    }

    /**
     * 索引删除
     * @param index
     * @return
     */
    public E remove(int index) {
        Node<E> curr;
        //只有头节点
        if(index ==0 && index == size-1){
            curr = headNode;
            headNode = null;
            //只删除头结点
        }else if(index == 0){
            curr = headNode;
            headNode = headNode.next;
            //删除中间元素
        }else if(index>0 && index<size-1){
            Node<E> node = headNode;
            for(int i=0;i<index-1;i++) {
                node = node.next;
            }
            curr = node.next;
            node.next = curr.next;
            //末尾元素
        }else {
            Node<E> node = node(index - 1);
            curr = node.next;
            node.next = null;
        }
        size--;
        return curr.data;
    }

    /***
     *  链表反转
     */
    public Node<E> reverse(){
        Node<E> current = headNode;
        Node<E> newHead = null;
        Node<E> next ;
        while (current != null){
            //保存当前节点的下一节点信息
            next = current.next;
            //将原来的链表断链,将current的下一个结点指向新链表的头结点
            current.next = newHead;
            newHead = current;
            current = next;
        }
        return newHead;
    }

    /**
     * 倒序遍历---递归
     * @param head
     */
    public void invertedOrder(Node<E> head){
        if(null==head){
            return;
        }
        invertedOrder(head.next);
        System.out.println(head.data);
    }

    /**
     *  用栈做倒序
     */
    public void invertedOrder2(){
        Node<E> current =  headNode;
        Stack<E> stack = new Stack<>();
        while (current != null){
            stack.push(current.data);
            current = current.next;
        }
        while (!stack.empty()){
            System.out.println(stack.pop());
        }
    }

    public static void main(String[] args) {
        TestSingleLinkedList<String> linkedList = new TestSingleLinkedList<>();
        linkedList.add("1");
        linkedList.add("2");
        linkedList.add("3");
        linkedList.add("4");
        linkedList.add("5");
        linkedList.add("6");
        linkedList.add("7");
        linkedList.add("8");
//        Node<String> reverse = linkedList.reverse();
//        System.out.println(reverse);
//        linkedList.invertedOrder(linkedList.headNode);
        linkedList.invertedOrder2();
        //        linkedList.add(1,"33");
//        System.out.println(linkedList.get(0));
//        System.out.println(linkedList.get(1));
//        System.out.println(linkedList.get(2));
//        String remove = linkedList.remove(2);
//        System.out.println(remove);
//        System.out.println("------------------------");
//        System.out.println(linkedList.get(0));
//        System.out.println(linkedList.get(1));


    }
}