问题：创建n个节点的循环链表并倒序显示。

2025年1月8日 | 7 分钟阅读

说明

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

算法

定义一个 Node 类，它表示列表中的一个节点。它有两个属性 data 和 next，next 将指向下一个节点。
定义另一个类来创建循环链表，它有两个节点：head和tail。它有两个方法：add()、display()和reverse()。
add() 将向列表中添加一个节点
1. 它首先检查头节点是否为 null，然后将节点作为头节点插入。
2. head 和 tail 都将指向新添加的节点。
3. 如果head不为null，新节点将成为新的tail，并且新tail将指向head，因为这是一个循环链表。
display() 将显示列表中存在的所有节点。
1. 定义一个新节点“current”，它将指向头节点。
2. 打印 current.data 直到 current 再次指向 head。
3. 在每次迭代中，current 将指向列表中的下一个节点。
reverse() 将以反向顺序打印循环链表。
1. 此方法检查当前节点的下一个节点是否为head，这意味着当前节点指向tail，然后它将打印tail节点的数据。
2. 通过考虑当前节点的下一个节点递归调用 reverse()，并从尾部开始以反向顺序打印所有节点。

解决方案

Python

#Represents the node of list.
class Node:
    def __init__(self,data):
      self.data = data;
      self.next = None;
 
class CreateList:
    #Declaring head and tail pointer as null.
    def __init__(self):
      self.head = Node(None);
      self.tail = Node(None);
      self.head.next = self.tail;
      self.tail.next = self.head;
      
    #This function will add the new node at the end of the list.
    def add(self,data):
      newNode = Node(data);
      #Checks if the list is empty.
      if self.head.data is None:
        #If list is empty, both head and tail would point to new node.
        self.head = newNode;
        self.tail = newNode;
        newNode.next = self.head;
      else:
        #tail will point to new node.
        self.tail.next = newNode;
        #New node will become new tail.
        self.tail = newNode;
        #Since, it is circular linked list tail will point to head.
        self.tail.next = self.head;
 
    #Displays all the nodes in the list
    def display(self):
        current = self.head;
        if self.head is None:
          print("List is empty");
          return;
        else:
            #Prints each node by incrementing pointer.
            print(current.data),
            while(current.next != self.head):
                current = current.next;
                print(current.data),
        
    #Reverse the order of the nodes present in the list.
    def reverse(self, current):
        #Checks if the next node is head, if yes then prints it.
        if(current.next == self.head):
            print(current.data),
            return;
        #Recursively calls the reverse function
        self.reverse(current.next);
        print(current.data),
    
    
class CircularLinkedList:
    cl = CreateList();
    #Adds data to the list
    cl.add(1);
    cl.add(2);
    cl.add(3);
    cl.add(4);
    cl.add(5);
    cl.add(6);
    print("Original List: ");
    cl.display();
    print("\nReversed List: ");
    #Print reversed list
    cl.reverse(cl.head);

输出

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

C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
//Represents the node of list.
struct node{
    int data;
    struct node *next;
};
 
//Declaring head and tail pointer as null.
struct node *head = NULL;
struct node *tail = NULL;
 
//This function will add the new node at the end of the list.
void add(int data){
    //Create new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = 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;
    }
}
 
//This function will display the nodes of circular linked list
void display(){
    struct node *current = head;
    if(head == NULL){
        printf("List is empty");
    }
    else{
         do{
             //Prints each node by incrementing pointer.
            printf("%d ", current->data);
            current = current->next;
        }while(current != head);
        printf("\n");
    }
}
 
//Reverse the order of the nodes present in the list.
void reverse(struct node *current) {
    //Checks if the next node is head, if yes then prints it.
    if(current->next == head) {
        printf("%d ",current->data);
        return;
    }
    //Recursively calls the reverse function
    reverse(current->next);
    printf("%d ",current->data);
}
    
int main()
{
    //Adds data to the list
    add(1);
    add(2);
    add(3);
    add(4);
    add(5);
    add(6);
    printf("Original List:\n");
    display();
    printf("Reversed List:\n");
    //Print reversed list
    reverse(head);
   
   return 0;
}

输出

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

JAVA

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

C#

using System; 
namespace CircularLinkedList 
{                     
    public class Program
    {
        //Represents the node of list.
        public class Node<T>{
            public T data;
            public Node<T> next;
            public Node(T value) {
                data = value;
                next = null;
            }
        }
        
        public class CreateList<T>{
            public Node<T> head = null;             
             public Node<T> tail = null;
            
            //This function will add the new node at the end of the list.
            public void add(T data){
                //Create new node
                Node<T> newNode = new Node<T>(data);
                //Checks if the list is empty.
                if(head == null){
                    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<T> current;
                if(head == null){
                    Console.WriteLine("List is empty");
                }
                else{
                    //Prints each node by incrementing pointer.
                    Console.Write(" "+head.data);
                    for(current = head.next; current!= head; current= current.next){
                        Console.Write(" "+current.data);
                    }
                }
                Console.WriteLine();
            }
                
            //Reverse the order of the nodes present in the list.
            public void reverse(Node<T> temp) {
                //Checks if the next node is head, if yes then prints it.
                if(temp.next == head) {
                    Console.Write(" "+temp.data);
                    return;
                }
                //Recursively calls the reverse function
                reverse(temp.next);
                Console.Write(" "+temp.data);
            }
    }
        
        public static void Main()
        {
            
            CreateList<int> cl = new CreateList<int>();
            cl.add(1);
            cl.add(2);
            cl.add(3);
            cl.add(4);
            cl.add(5);
            cl.add(6);
            Console.WriteLine("Original List: ");
            cl.display();
            Console.WriteLine("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

PHP

<!DOCTYPE html>
<html>
<body>
<?php
//Represents the node of list.
class Node{
    public $data;
    public $next;
    function __construct($data){
        $this->data = $data;
        $this->next = NULL;
    }
}
class CreateList{
    //Declaring head and tail pointer as null.
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    //This function will add the new node at the end of the list.
    function add($data){
        //Create new node
        $newNode = new Node($data);
        //Checks if the list is empty.
        if($this->head == NULL){
            //If list is empty, both head and tail would point to new node.
            $this->head = $newNode;
            $this->tail = $newNode;
            $newNode->next = $this->head;
        }
        else{
            //tail will point to new node.
            $this->tail->next = $newNode;
            //New node will become new tail.
            $this->tail = $newNode;
            //Since, it is circular linked list tail will point to head.
            $this->tail->next = $this->head;
        }
    }
    //Displays all the nodes in the list
    function display() {
        $current = $this->head;
        if($this->head == NULL) {
            echo "List is empty";
        }
        else {
             do{
                //Prints each node by incrementing pointer.
                echo(" $current->data");
                $current = $current->next;
            }while($current != $this->head);
            echo "<br>";
        }
    }
    //Reverse the order of the nodes present in the list.
    function reverse($current) {
        //Checks if the next node is head, if yes then prints it.
        if($current->next == $this->head) {
            echo " $current->data";
            return;
        }
        //Recursively calls the reverse function
        $this->reverse($current->next);
        echo " $current->data";
    }
        
}
$cl = new CreateList();
//Adds data to the list
$cl->add(1);
$cl->add(2);
$cl->add(3);
$cl->add(4);
$cl->add(5);
$cl->add(6);
echo "Original List: <br>";
$cl->display();
echo "<br>Reversed List: <br>";
//Print reversed list
$cl->reverse($cl->head);
?>
</body>
</html>

输出

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

下一主题#

问题：创建n个节点的循环链表并倒序显示。

说明

算法

解决方案

Python

C

JAVA

C#

PHP

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

程序

问题：创建n个节点的循环链表并倒序显示。

说明

算法

解决方案

Python

C

JAVA

C#

PHP

相关帖子

交换两个数字的程序

单向链表示例

打印数组中奇数位置元素的程序

查找字符串的所有排列的程序

将小时转换为分钟和秒的程序

打印数字图案 17 的程序

打印 1 到 100 之间的所有快乐数的程序

从单向链表中删除中间节点的程序

计算字符串中字符总数的程序

打印 1 到 100 之间的所有普罗尼克数（Pronic number）的程序

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器