[数据结构与算法]java实现一个单链表，并实现链表的反转

/**
 * 实现单链表的反转功能
 */

public class LinkedListTestReverse {
    public static void main(String[] args) {
        //设计一个单链表实现其单链表的增删操作
        ListNodeS list = new ListNodeS();
        list.addNode(3);
        list.addNode(4);
        list.addNode(5);
        list.printInfo();
//        list.deleteNode(2);
//        list.printInfo();
//        list.deleteNodeData(list.head.next);
//        list.printInfo();
        //实现链表的特定的功能
        //1、将链表进行反转
        ListNodeS listNodeS = list.reverseList(list);
        listNodeS.printInfo();

    }
}
class ListNodeS{
    Node head=null;//头节点

    class Node{
        int data;
        Node next;
        public Node(int data) {
            this.data=data;
        }
    }
    //向链表中添加数据
    public void addNode(int d){
        Node newNode = new Node(d);
        if(head==null){
            head=newNode;
            return;
        }
        Node temp=head;
        while (temp.next!=null){
            temp=temp.next;
        }
        temp.next=newNode;
    }

    //遍历链表中的元素
    public void printInfo(){
        Node cur=head;
        if(head==null){
            return;
        }
        while (cur!=null){
            System.out.println(cur.data);
            cur=cur.next;
        }
    }
    //获取链表的长度
    public int length(){
        int lenth=0;
        Node temp=head;
        while(temp!=null){
            lenth++;
            temp=temp.next;
        }
        return lenth;
    }

    //删除链表中的第index个元
    public boolean deleteNode(int index){
        if(index<1||index>length()){
            return false;
        }
        if(index==1){
            head=head.next;
            return true;
        }
        int i=1;
        Node pre=head;
        Node cur=pre.next;
        while (cur!=null){
            if(i==index){
                pre.next=cur.next;
                return true;
            }
            pre=cur;
            cur=cur.next;
            i++;
        }
        return false;
    }

    //不知道头指针的情况下进行删除
    public boolean deleteNodeData(Node n){
        if(n==null||n.next==null){
            return false;
        }
        int temp=n.data;
        n.data=n.next.data;
        n.next.data=temp;
        n.next=n.next.next;
        System.out.println("删除成功");
        return true;
    }

    //链表的反转
    public ListNodeS reverseList(ListNodeS listNodeS){
        Node cur=listNodeS.head;
        Node pre=null;
        while(cur!=null){
            Node next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        return listNodeS;
    }
}

在进行链表的反转的时候，可以使用栈进行?