📌  相关文章
📜  数据结构示例-创建n个节点的循环链表并反序打印

📅  最后修改于: 2020-10-15 06:01:18             🧑  作者: Mango

问:程序创建一个n个节点的循环链接列表,并以相反的顺序显示它。

说明

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

算法

  • 定义一个Node类,该类代表列表中的一个节点。它具有两个属性数据,下一个将指向下一个节点。
  • 定义另一个用于创建循环链接列表的类,它具有两个节点:head和tail。它有两种方法:add(),display()和reverse()。
  • add()将节点添加到列表中:
    1. 它首先检查head是否为空,然后将节点插入为head。
    2. 头部和尾部都将指向新添加的节点。
    3. 如果head不为空,则新节点将是新的尾,并且新的尾将指向head,因为它是一个循环链接列表。
  • display()将显示列表中存在的所有节点。
    1. 定义一个新节点“当前”,该节点将指向头部。
    2. 打印current.data,直到current再次指向head。
    3. 当前将在每次迭代中指向列表中的下一个节点。
  • reverse()将以相反的顺序print循环链接列表。
    1. 此方法检查当前节点的下一个节点是否为head,这表示当前节点指向尾部,然后将print该尾节点的数据。
    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 
#include 
#include 
 
//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{
            public T data;
            public Node next;
            public Node(T value) {
                data = value;
                next = null;
            }
        }
        
        public class CreateList{
            public Node head = null;             
             public Node tail = null;
            
            //This function will add the new node at the end of the list.
            public void add(T data){
                //Create new node
                Node newNode = new Node(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 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 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 cl = new CreateList();
            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:




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 "
"; } } //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:
"; $cl->display(); echo "
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