如何在保留原始顺序的同时反转 java 中的链表？

Question

我想反转一个链表。 我可以反转列表，但这样做也会影响原始列表。如何在使用显示 function 时同时查看原始和反向链表？

要求以下代码库...

请帮助使用 display 和 reverseLink 方法。 还添加了所有其他类。

public class Node {
    int data;
    Node link;

    public Node(int data, Node link) {
        this.data = data;
        this.link = link;
    }
    
    public Node() {
        this.data = 0;
        this.link = null;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getLink() {
        return link;
    }

    public void setLink(Node link) {
        this.link = link;
    }
}

public class Sa_LinkedList {

    Node start;
    Node end;
    int size;
    public Sa_LinkedList() {
        start=null;
        end=null;
        size=0;
    }
    
    public boolean isEmpty() {
        return start==null;
    }

    public int getSize() {
        return size;
    }
    
    public void insertAtStart(int val) {
        Node newNd=new Node(val,null);
        size++;
        
        if(start==null) {
            start=newNd;
            end=start;
        }
        else
        {
            newNd.setLink(start);
            start=newNd;
        }
    }
    
    public void insertAtEnd(int val) {
     Node newNd=new Node(val,null);
     size++;
    
     if(end==null) {
         end=start=newNd;
     }
     else {
         end.setLink(newNd);
         end=newNd;
     }
    }

        public void insertAtPos(int val,int pos) {
            Node newNd=new Node(val,null);
            Node ptr=start;
            pos=pos-1;
            for(int i=0;i<size;i++) {
                
                if(i==pos) {
                Node temp=ptr.getLink();
                ptr.setLink(newNd);
                newNd.setLink(temp);
                break;
                }
                ptr=ptr.getLink();
            }
            size++;
        }
            
        
        public void deleteAtPos(int pos) {
    
            if(pos==1) {
                start=start.getLink();
                size--;
                return;
            }
            if(pos==size) {
              Node s=start;
              Node t=start;
              
              while(t!=end) {
                  s=t;
                  t=t.getLink();
              }
              end=s;
              end.setLink(null);
              size--;
              return;
              
            }
            Node ptr=start;
            pos=pos-1;
            for(int i=0;i<size;i++) {
                if(i==pos) {
                    Node temp=ptr.getLink();
                    temp=temp.getLink();
                    ptr.setLink(temp);
                    break;
                }
                ptr=ptr.getLink();
            }
            size--;
        }
 
    //*Function for displaying the linkedlist
    public void display() {
        System.out.println("Displaying the linkedlist elements:");
        Node ptr=start;
    
        if (size==0)
        {
            System.out.println("sorry...------List is empty------");
            return;
        }
        if(start.getLink()==null)
        {
            System.out.println(start.getData());
            return;
        }
        while(ptr.getLink()!=null) {
            System.out.println(ptr.getData()+",");
            ptr=ptr.getLink();
        }
        System.out.println(ptr.getData()+"\n");
    }
    
    
    public void reverseLink() {
        Node current=start;
        Node next=null;
        Node prev=null;
        
        while(current!=null) {
            
            next=current.getLink();
            current.setLink(prev);
            prev=current;
            current=next;
        }
        start=prev;
    }
}

Answer 1

1. 复制列表并反转一个或
2. 或建立一个双向链表。 在双向链表中，每个节点都知道它的前一个节点和下一个节点。 有了这个，您可以轻松地以相反的顺序打印列表

Answer 2

JDK 中有Collections.reverse(List)方法可用。 您可以以它的方法为例：

public static void reverse(List<?> list) {
    int size = list.size();
    if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
        for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
            swap(list, i, j);
    } else {
        // instead of using a raw type here, it's possible to capture
        // the wildcard but it will require a call to a supplementary
        // private method
        ListIterator fwd = list.listIterator();
        ListIterator rev = list.listIterator(size);
        for (int i=0, mid=list.size()>>1; i<mid; i++) {
            Object tmp = fwd.next();
            fwd.set(rev.previous());
            rev.set(tmp);
        }
    }
}