📅  最后修改于: 2020-10-15 06:01:18             🧑  作者: Mango
在此程序中,我们创建一个循环链接列表,然后以相反的顺序遍历该列表并print节点。
#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
#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
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
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
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