单向链表（singleLinkedList） java实现

package com.important.data.struct.LinkedListSingle;

public class SingleLinkedList
{

    public static void main(String[] args)
    {
        SingleLinkedListType<String> singleLinkedListType = new SingleLinkedListType<>();
        for(int i=0;i<5;i++){
            String temp = i+"";
            singleLinkedListType.add(temp);
        }
        System.out.println("单链表的大小： ");
        System.out.println(singleLinkedListType.size());
//        System.out.println("单链表的第一个位置处的值为： ");
//        System.out.println(singleLinkedListType.get(1));
        System.out.println("单链表为：");
        singleLinkedListType.println();

//        singleLinkedListType.add(0, "xixi");
//        singleLinkedListType.println();

//        singleLinkedListType.addFirst("kaishi");
//        singleLinkedListType.println();
//        System.out.println(singleLinkedListType.size());

//        singleLinkedListType.remove(2);
//        singleLinkedListType.println();

//        singleLinkedListType.removeTail();
//        singleLinkedListType.println();

        singleLinkedListType.reverse();
        System.out.println("链表反转之后的链表为： ");
        singleLinkedListType.println();

    }

}
class SingleLinkedListType<T>{

    //静态内部类表示单链表的节点
    private static class Node<T>{
        public T date;  //数据域
        Node<T> next;   //后指针
        @SuppressWarnings("unused")
        public Node(T d,Node<T> n){
            date = d;
            next = n;
        }
        public Node(T d){
            date = d;
            next = null;
        }
    }

    private int theSize;
    private Node<T> head;

    public SingleLinkedListType()
    {
        clear();
    }
    //清除
    public void clear(){
        theSize = 0;
        head = null;
    }

    //大小
    public int size(){
        return theSize;
    }

    //添加结点
    public void add(T x){
        Node<T> newNode = new Node<T>(x);
        if(head == null){
            head = newNode ;
        }else {
            Node<T> pNode = head;
            while(pNode.next!=null){
                   pNode = pNode.next;
            }
            pNode.next = newNode;
        }
        theSize++;
    }

    //插入节点
    public void add(int index ,T x){
        checkRange(index);
        Node<T> pNode = getNode(index);
        Node<T> newNode = new Node<T>(x);
        newNode.next = pNode.next;
        pNode.next = newNode;
        theSize++;
    }

    //加在头节点
    public void addFirst(T x){
        Node<T> newNode = new Node<T>(x);
        newNode.next = head;
        head =newNode;
        theSize++;
    }

  //检查index是否越界
    public void checkRange(int index){
        if (index<0 || index > size())
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size();
    }

    //获取节点数据
    public T get(int index){
        Node<T> pNode = getNode(index);
        return pNode.date;
    }

    //获取节点
    public Node<T> getNode(int index){
        checkRange(index);
        Node<T> pNode = head;
        for(int i=0;i<index;i++){
            pNode = pNode.next;
        }
        return pNode;
    }

    //删除尾节点
    public void removeTail(){
        remove(size()-1);
        theSize--;
    }

    //删除节点
    public void remove(int index){
        checkRange(index);

        Node<T> pNode = getNode(index);
        Node<T> temp = head;
        for(int i=0;i<index-1;i++){
            temp = temp.next;
        }
        temp.next = pNode.next;
        pNode.next = null;
        theSize--;
    }

    //输出
    public void println(){
        Node<T> pNode = head;
        while(pNode!=null){
            System.out.print(pNode.date+" ");
            pNode = pNode.next;
        }
        System.out.println();
    }


    //实现反转
    public void reverse(){
        Node<T> pre = head;     //前一个节点 
        Node<T> curr = head.next;   //当前节点
        Node<T> next ;  //中介节点 作为临时跳转

        while(curr!=null){
            next = curr.next;   //提取出当前节点的下一个节点 保存到临时节点中
            curr.next = pre;    //当前节点的前一个节点作为当前节点的下一个节点，刚好实现反转
            pre = curr;     //此时当前节点则为下一次反转的当前节点的前一个节点
            curr = next;    //当前节点的下一个节点此时为下一次反转的当前节点
        }
        head.next = null;   //
        head = pre;     //当前节点的前一个节点作为头节点  即最开始的节点

    }


}