Java链表操作（单链表）

#单链表的操作
本方法实现了以下操作：

• 表头添加元素

• 表头删除元素
• 查找指定元素
• 删除指定元素
• 链表反转 - 遍历实现
• 链表反转 - 递归实现
• 链表反转- LinkedList的反转
• 遍历求元素个数

public class SingleLinkedList {
private int size;//链表节点的个数
private Node head;//头节点

public SingleLinkedList(){
    size = 0;
    head = null;
}

//链表的每个节点类
private class Node{
    private Object data;//每个节点的数据
    private Node next;//每个节点指向下一个节点的连接
    
    public Node(Object data){
        this.data = data;
    }
}

//在链表头添加元素
public Object addHead(Object obj){
    Node newHead = new Node(obj);
    if(size == 0){
        head = newHead;
    }else{
        newHead.next = head;
        head = newHead;
    }
    size++;
    return obj;
}

//在链表头删除元素
public Object deleteHead(){
    Object obj = head.data;
    head = head.next;
    size--;
    return obj;
}

//查找指定元素，找到了返回节点Node，找不到返回null
public Node find(Object obj){
    Node current = head;
    int tempSize = size;
    while(tempSize > 0){
        if(obj.equals(current.data)){
            return current;
        }else{
            current = current.next;
        }
        tempSize--;
    }
    return null;
}

//删除指定的元素，删除成功返回true
public boolean delete(Object value){
    if(size == 0){
        return false;
    }
    Node current = head;
    Node previous = head;
    while(current.data != value){
        if(current.next == null){
            return false;
        }else{
            previous = current;
            current = current.next;
        }
    }
    //如果删除的节点是第一个节点
    if(current == head){
        head = current.next;
        size--;
    }else{//删除的节点不是第一个节点
        previous.next = current.next;
        size--;
    }
    return true;
}

//判断链表是否为空
public boolean isEmpty(){
    return (size == 0);
}

//显示节点信息
public void display(){
    if(size >0){
        Node node = head;
        int tempSize = size;
        if(tempSize == 1){//当前链表只有一个节点
            System.out.println("["+node.data+"]");
            return;
        }
        while(tempSize>0){
            if(node.equals(head)){
                System.out.print("["+node.data+"->");
            }else if(node.next == null){
                System.out.print(node.data+"]");
            }else{
                System.out.print(node.data+"->");
            }
            node = node.next;
            tempSize--;
        }
        System.out.println();
    }else{//如果链表一个节点都没有，直接打印[]
        System.out.println("[]");
    }
    
}
//  链表反转 - 遍历法 - @Chase
public void reverse1() {
        //上一个节点
    Node previousNode = null;
    //当前节点
    Node currentNode = head;
    //头节点
    Node headNode = null;
    while (currentNode != null) {
        //将当前节点的下一个节点保存起来
        Node nextNode = currentNode.next;
        //判断当前节点是否为尾节点
        if (nextNode == null) {
            headNode = currentNode;
        }
        //将当前节点指向上一个节点，反转
        currentNode.next = previousNode;
        //上一个节点保存当前节点的信息，即上一个节点指向当前节点的下一个节点
        previousNode = currentNode;
        //当前节点变为当前节点的下一个节点
        currentNode = nextNode;
    }
    head = headNode;
}

//链表反转- 递归 - @Chase
static Node reverseLinkedList(Node node) {
//判断尾节点和空链表
    if (node == null || node.next == null) {
        return node;
    } else {
    //递归
        Node headNode = reverseLinkedList(node.next);
        node.next.next = node;
        node.next = null;
        return headNode;
    }
}
    public void reverse2() {
        head =  reverseLinkedList(head);
    }





    //遍历求个数 - @Chase
    public int findall(){
        Node current = head;
        int tempSize = size;
        int sum = 1;
        while(current!=null){
            System.out.println(sum);
            sum+=1;
            current = current.next;
        }
        return sum;
    }
}