Java 泛型单向链表

// MyList.java in the package
public interface MyList<T> {

 	void push(T element); //向链表中添加元素 @param element 待添加的元素
 
 	boolean contains(T element); //链表中是否存在指定元素
 
 	boolean pop(T element); //删除指定元素 @param element 待删除待元素 
						 //@return 删除是否成功，如果元素不在链表中，返回 false
 	int size(); //返回链表⻓度

	void reverse(); //反转链表,如 1->2->3->4 反转后是 4->3->2->1
	
	//void sort(Comparator<? super T> comparator);  选做，链表排序
}

public class Main<T> implements MyList<T>{

    private static class Node<T> {
        private T data;
        private Node<T> next;

        public Node(T data) { this.data = data; }
        public Node<T> getNext() { return next; }
        public void setNext(Node<T> next) { this.next = next; }
        public T getData() { return data; }
        public void setData(T data) { this.data = data; }
    }

    private int size;  // 链表长度
    private Node<T> head;  // 头节点

    Main() { size = 0;  head = null; }
    
    @Override
    //向链表中添加元素，element为待添加的元素
    public void push(T element) {
        Node<T> newNode = new Node<>(element);
        if(head == null) {
            head = newNode;
        } else {
            Node<T> temp = head;
            while(temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
        ++size; //链表长度加1
    }

    @Override
    //查找链表中是否存在指定元素
    public boolean contains(T element) {
        Node<T> p = head; // 定义链表查找指针
        while(p != null) {
            if (p.data == element) {
                return true; // 成功找到该元素，返回true
            } else {
                p = p.next;
            }
        }
        return false;
    }

    @Override
    // 删除指定的元素；删除成功返回true，没找到元素返回false
    public boolean pop(T element) {
        if(head.data == element) { // 如果待删除元素在头节点中
            head = head.next; // 让头节点的下一个节点做头节点(删除头节点)
            --size;
            return true;
        } else { // 如果待删除元素不在头节点中
            Node<T> p = head; // 定义链表查找指针
            while (p.next != null) {
                if (p.next.data == element) {
                    p.next = p.next.next;
                    --size;
                    return true;
                } else {
                    p = p.next;
                }
            }
            return false;
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void reverse() {
        if(head == null || head.getNext() == null)
            return ;  //return head;
        Node<T> pre = head;
        Node<T> cur = head.getNext();
        Node<T> tmp;
        while(cur != null) {
            tmp = cur.getNext();
            cur.setNext(pre);
            pre = cur;
            cur = tmp;
        }
        head.setNext(null);
        head = pre;
    }

    // 测试int型数据的main函数
    public static void main(String[] args) {
        Main<Integer> a = new Main<>();
        Node<Integer> p = null;

        System.out.println("\t测试size()方法");
        System.out.println("Size = " + a.size());

        System.out.println("\t测试push()方法");
        a.push(1);  a.push(2);  a.push(3);  a.push(4);  a.push(5);
        System.out.println("Size = " + a.size());
        p = a.head;
        while(p != null) {
            System.out.print(p.getData() + "\t");
            p = p.next;
        }

        System.out.println("\n\t测试contains()方法");
        if(a.contains(3)) System.out.println("链表中存在元素3");
        else System.out.println("链表中不存在元素3");
        if(a.contains(8)) System.out.println("链表中存在元素8");
        else System.out.println("链表中不存在元素8");

        System.out.println("\t测试pop()方法");
        if(a.pop(6)) System.out.println("链表删除了元素6");
        else System.out.println("链表中不含有元素6，删除失败(待删除元素不在链表中)");
        System.out.println("Size = " + a.size());
        if(a.pop(1)) System.out.println("链表删除了元素1(待删除元素在头节点)");
        else System.out.println("链表中不含有元素1");
        System.out.println("Size = " + a.size());
        if(a.pop(4)) System.out.println("链表删除了元素4(待删除元素不在头节点)");
        else System.out.println("链表中不含有元素4");
        System.out.println("Size = " + a.size());
        p = a.head;
        while(p != null) {
            System.out.print(p.getData() + "\t");
            p = p.next;
        }

        System.out.println("\n\t测试reverse()方法");
        a.reverse(); // 反转链表
        p = a.head;
        while(p != null) {
            System.out.print(p.getData() + "\t");
            p = p.next;
        }
    }
}

运行结果:
	测试size()方法
Size = 0
	测试push()方法
Size = 5
1	2	3	4	5	
	测试contains()方法
链表中存在元素3
链表中不存在元素8
	测试pop()方法
链表中不含有元素6，删除失败(待删除元素不在链表中)
Size = 5
链表删除了元素1(待删除元素在头节点)
Size = 4
链表删除了元素4(待删除元素不在头节点)
Size = 3
2	3	5	
	测试reverse()方法
5	3	2

• 对于reverse()方法，还可以用递归实现：

public Node<T> reverse(Node<T> head) {
    if(head == null || head.getNext() == null) {
        return ; //空链表或者单个节点的链表则直接返回
    }
    // 递归反转 空间复杂度较大
    Node<T> rev = reverse(head.getNext()); //找到链表的最后一个节点，此时head为原链表倒数第二个节点，rev为原链表最后一个节点
    head.getNext().setNext(head); // 1->2->3->4->5 变为 5->4和1->2->3->4
    head.setNext(null);
    return rev;
}
在方法外用: head = reserve(head); 即可实现链表的反转
当链表长度较长时，递归反转链表的内存空间占用率过高，可能会导致程序崩溃，因此未选择该种方法