单向链表

/**
 * @Author: subd
 * @Date: 2019/5/6 15:51
 */
public class SingleNodeList<E> {
    Node head;
    Node last;
    int size;

    private static class Node<E> {
        E item;
        Node<E> next;

        Node(E element) {
            this.item = element;
        }

        @Override
        public String toString() {
            return item.toString();
        }
    }

    public void add(E e) {
        Node<E> newNode = new Node(e);
        //第一次添加
        if (last == null) {
            head = newNode;
            last = newNode;
        } else {
            last.next = newNode;
            last = newNode;
        }
        size++;
    }

    public void add(int index, E e) {
        Node<E> newNode = new Node(e);
        if (index <= size && index >= 0) {
            if (size == 0) {
                //空链表
                head = newNode;
                last = newNode;
            } else if (size == index) {
                //尾部追加
                last = newNode;
                last.next = newNode;
            } else {
                //中间插入
                Node<E> pre = head;
                Node<E> next = head.next;
                int i = 1;
                while (i < index) {
                    pre = next;
                    next = next.next;
                    i++;
                }
                pre.next = newNode;
                newNode.next = next;
            }

        } else {
            throw new IndexOutOfBoundsException("索引越界！");
        }
        size++;
    }

    public E get(int index) {

        if (index >= 0 && index <= size) {
            int i = 0;
            Node<E> node = head;
            while (i < index) {
                node = node.next;
                i++;
            }
            return node.item;
        } else {
            throw new IndexOutOfBoundsException("索引越界！");
        }
    }

    public boolean remove(int index) {
        if (index >= 0 && index <= size) {
            if (size - 1 == 0) {
                //移除开头
                head = head.next;
                size--;
                return true;
            } else {
                //移除中间索引位置 移除最后一个也要这样走一个O（n）
                int i = 0;
                Node<E> node = head;
                while (i < index - 1) {
                    node = node.next;
                    i++;
                }
                //索引处的节点
                Node<E> cur = node.next;
                if (cur != null) {
                    node.next = cur.next;
                }
                size--;
                return true;
            }
        } else {
            throw new IndexOutOfBoundsException("索引越界！");
        }
    }

    public boolean remove(E e) {
        if (size <= 0) {
            throw new IndexOutOfBoundsException("索引越界！");
        }
        Node<E> node = head;
        int i = 0;
        while (node != null) {
            if (node.item.equals(e)) {
                remove(i);
            }
            i++;
            node = node.next;
        }
        return true;
    }

    public void reverse() {
        if (size <= 1) {
            return;
        }
        Node<E> pre = head;
        Node<E> cur = head.next;
        Node<E> tmp;
        while (cur != null) {
            tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        last = pre;
        head.next = null;
        head = last;
    }

    /**
     * 递归方式
     *
     * @param head
     */
    public void reverse(Node head) {
        if (head == null || head.next == null) {
            //将未入栈的初始list的尾部赋给head
            this.head = head;
            return;
        }
        //压栈
        reverse(head.next);
        //出栈
        head.next.next = head;
        head.next = null;
        //最后一个出栈的赋给last
        last = head;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node<E> node = head;
        for (int i = 0; i < size; i++) {
            sb.append(node.toString());
            node = node.next;
        }
        return "SingleNodeList{" +
                sb.toString() +
                '}';
    }

    public static void main(String[] args) {
        SingleNodeList<Integer> list = new SingleNodeList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
//        list.remove(2);
//        list.remove(4);
        list.reverse();
        System.out.println(list.toString() + "size:" + list.size);
    }
}