创建n个节点的循环链表并以相反顺序显示的Java程序

1 简介

在此程序中，我们创建一个循环链表，然后以相反的顺序遍历该列表并打印节点。

2 算法思路

• 定义一个Node类，该类代表列表中的一个节点。它具有两个属性数据，下一个将指向下一个节点。
• 定义另一个用于创建循环链表的类，它具有两个节点：head和tail。它有两种方法：add（），display（）和reverse（）。
• add（）将节点添加到列表中：
  • 它首先检查head是否为空，然后将节点插入为head。
  • 头部和尾部都将指向新添加的节点。
  • 如果head不为null，则新节点将是新的tail，而新的tail将指向head，因为它是一个循环链接列表。
• 定义一个新节点“current”，该节点将指向头部。
• 打印current.data，直到current再次指向head。
• 当前将在每次迭代中指向列表中的下一个节点。
• 此方法检查当前节点的下一个节点是否为head，这表示当前节点指向尾部，然后将打印该尾节点的数据。
• 通过考虑当前节点旁边的节点来递归调用reverse（），并从尾部开始以相反的顺序打印出所有节点。

3 程序实现

/**
 * 一点教程网： http://www.yiidian.com
 */
public class ReverseList {  
            //Represents the node of list.  
            public class Node{  
                int data;  
                Node next;  
                public Node(int data) {  
                    this.data = data;  
                }  
            }  
  
            //Declaring head and tail pointer as null.  
            public Node head = null;  
            public Node tail = null;  
  
            //This function will add the new node at the end of the list.  
            public void add(int data){  
                //Create new node  
                Node newNode = new Node(data);  
                //Checks if the list is empty.  
                if(head == null) {  
                     //If list is empty, both head and tail would point to new node.  
                    head = newNode;  
                    tail = newNode;  
                    newNode.next = head;  
                }  
                else {  
                    //tail will point to new node.  
                    tail.next = newNode;  
                    //New node will become new tail.  
                    tail = newNode;  
                    //Since, it is circular linked list tail will point to head.  
                    tail.next = head;  
                }  
            }  
  
            //Displays all the nodes in the list  
            public void display() {  
                Node current = head;  
                if(head == null) {  
                    System.out.println("List is empty");  
                }  
                else {  
                     do{  
                        //Prints each node by incrementing pointer.  
                        System.out.print(" "+ current.data);  
                        current = current.next;  
                    }while(current != head);  
                    System.out.println();  
                }  
            }  
  
            //Reverse the order of the nodes present in the list.  
            public void reverse(Node current) {  
                //Checks if the next node is head, if yes then prints it.  
                if(current.next == head) {  
                    System.out.print(" "+current.data);  
                    return;  
                }  
                //Recursively calls the reverse function  
                reverse(current.next);  
                System.out.print(" "+current.data);  
            }  
  
            public static void main(String[] args) {  
                ReverseList cl = new ReverseList();  
                cl.add(1);  
                cl.add(2);  
                cl.add(3);  
                cl.add(4);  
                cl.add(5);  
                cl.add(6);  
                System.out.println("Original List: ");  
                cl.display();  
                System.out.println("Reversed List: ");  
                //Print reversed list  
                cl.reverse(cl.head);  
            }  
} 

输出结果为：

Original List: 
1 2 3 4 5 6
Reversed List: 
6 5 4 3 2 1