Thủ Thuật Hướng dẫn Circular linked list example 2022
Pro đang tìm kiếm từ khóa Circular linked list example được Update vào lúc : 2022-12-30 22:06:07 . Với phương châm chia sẻ Kinh Nghiệm Hướng dẫn trong nội dung bài viết một cách Chi Tiết 2022. Nếu sau khi Read Post vẫn ko hiểu thì hoàn toàn có thể lại Comment ở cuối bài để Mình lý giải và hướng dẫn lại nha.
A Complete Overview Of Circular Linked List.
Nội dung chính
- Circular Linked List In C++DeclarationBasic OperationsAdvantages/DisadvantagesApplications Of Circular Linked ListRecommended ReadingVideo liên quan
A circular linked list is a variation of the linked list. It is a linked list whose nodes are connected in such a way that it forms a circle.
In the circular linked list, the next pointer of the last node is not set to null but it contains the address of the first node thus forming a circle.
=> Visit Here To Learn C++ From Scratch.
What You Will Learn:
- Circular Linked List In C++
- DeclarationBasic Operations
- InsertionDeletionTraversal
Advantages/DisadvantagesApplications Of Circular Linked ListConclusionRecommended Reading
Circular Linked List In C++
The arrangement shown below is for a singly linked list.
A circular linked list can be a singly linked list or a doubly linked list. In a doubly circular linked list, the previous pointer of the first node is connected to the last node while the next pointer of the last node is connected to the first node.
Its representation is shown below.
Declaration
We can declare a node in a circular linked list as any other node as shown below:
struct Node
int data;
struct Node *next;
;
In order to implement the circular linked list, we maintain an external pointer last that points to the last node in the circular linked list. Hence last->next will point to the first node in the linked list.
By doing this we ensure that when we insert a new node the beginning or the end of the list, we need not traverse the entire list. This is because the last points to the last node while last->next points to the first node.
This wouldnt have been possible if we had pointed the external pointer to the first node.
Basic Operations
The circular linked list supports insertion, deletion, and traversal of the list. We will discuss each of the operations in detail now.
Insertion
We can insert a node in a circular linked list either as a first node (empty list), in the beginning, in the end, or in between the other nodes. Let us see each of these insertion operations using a pictorial representation below.
#1) Insert in an empty list
When there are no nodes in circular list and the list is empty, the last pointer is null, then we insert a new node N by pointing the last pointer to the node N as shown above. The next pointer of N will point to the node N itself as there is only one node. Thus N becomes the first as well as last node in the list.
#2) Insert the beginning of the list
As shown in the above representation, when we add a node the beginning of the list, the next pointer of the last node points to the new node N thereby making it a first node.
N->next = last->next
Last->next = N
#3) Insert the end of the list
To insert a new node the end of the list, we follow these steps:
N-> next = last ->next;
last ->next = N
last = N
#4) Insert in between the list
Suppose we need to insert a new node N between N3 and N4, we first need to traverse the list and locate the node after which the new node is to be inserted, in this case, its N3.
After the node is located, we perform the following steps.
N -> next = N3 -> next;
N3 -> next = N
This inserts a new node N after N3.
Deletion
The deletion operation of the circular linked list involves locating the node that is to be deleted and then freeing its memory.
For this we maintain two additional pointers curr and prev and then traverse the list to locate the node. The given node to be deleted can be the first node, the last node or the node in between. Depending on the location we set the curr and prev pointers and then delete the curr node.
A pictorial representation of the deletion operation is shown below.
Traversal
Traversal is a technique of visiting each and every node. In linear linked lists like singly linked list and doubly linked lists, traversal is easy as we visit each node and stop when NULL is encountered.
However, this is not possible in a circular linked list. In a circular linked list, we start from the next of the last node which is the first node and traverse each node. We stop when we once again reach the first node.
Now we present an implementation of the circular linked list operations using C++ and Java. We have implemented insertion, deletion and traversal operations here. For a clear understanding, we have depicted the circular linked list as
Thus to the last node 50, we again attach node 10 which is the first node, thereby indicating it as a circular linked list.
#include<iostream>
using namespace std;
struct Node
int data;
struct Node *next;
;
//insert a new node in an empty list
struct Node *insertInEmpty(struct Node *last, int new_data)
// if last is not null then list is not empty, so return
if (last != NULL)
return last;
// allocate memory for node
struct Node *temp = new Node;
// Assign the data.
temp -> data = new_data;
last = temp;
// Create the link.
last->next = last;
return last;
//insert new node the beginning of the list
struct Node *insertAtBegin(struct Node *last, int new_data)
//if list is empty then add the node by calling insertInEmpty
if (last == NULL)
return insertInEmpty(last, new_data);
//else create a new node
struct Node *temp = new Node;
//set new data to node
temp -> data = new_data;
temp -> next = last -> next;
last -> next = temp;
return last;
//insert new node the end of the list
struct Node *insertAtEnd(struct Node *last, int new_data)
//if list is empty then add the node by calling insertInEmpty
if (last == NULL)
return insertInEmpty(last, new_data);
//else create a new node
struct Node *temp = new Node;
//assign data to new node
temp -> data = new_data;
temp -> next = last -> next;
last -> next = temp;
last = temp;
return last;
//insert a new node in between the nodes
struct Node *insertAfter(struct Node *last, int new_data, int after_item)
//return null if list is empty
if (last == NULL)
return NULL;
struct Node *temp, *p.;
p. = last -> next;
do
if (p. ->data == after_item)
temp = new Node;
temp -> data = new_data;
temp -> next = p. -> next;
p. -> next = temp;
if (p. == last)
last = temp;
return last;
p. = p. -> next;
while(p. != last -> next);
cout << “The node with data “<<after_item << ” is not present in the list.” << endl;
return last;
//traverse the circular linked list
void traverseList(struct Node *last)
struct Node *p.;
// If list is empty, return.
if (last == NULL)
cout << “Circular linked List is empty.” << endl;
return;
p. = last -> next; // Point to the first Node in the list.
// Traverse the list starting from first node until first node is visited again
do
cout << p. -> data << “==>”;
p. = p. -> next;
while(p. != last->next);
if(p. == last->next)
cout<<p.->data;
cout<<“nn”;
//delete the node from the list
void deleteNode(Node** head, int key)
// If linked list is empty retun
if (*head == NULL)
return;
// If the list contains only a single node,delete that node; list is empty
if((*head)->data==key && (*head)->next==*head)
không lấy phí(*head);
*head=NULL;
Node *last=*head,*d;
// If key is the head
if((*head)->data==key)
while(last->next!=*head) // Find the last node of the list
last=last->next;
// point last node to next of head or second node of the list
last->next=(*head)->next;
không lấy phí(*head);
*head=last->next;
// end of list is reached or node to be deleted not there in the list
while(last->next!=*head&&last->next->data!=key)
last=last->next;
// node to be deleted is found, so không lấy phí the memory and display the list
if(last->next->data==key)
d=last->next;
last->next=d->next;
cout<<“The node with data “<<key<<” deleted from the list”<<endl;
không lấy phí(d);
cout<<endl;
cout<<“Circular linked list after deleting “<<key<<” is as follows:”<<endl;
traverseList(last);
else
cout<<“The node with data “<< key << ” not found in the list”<<endl;
// main Program
int main()
struct Node *last = NULL;
last = insertInEmpty(last, 30);
last = insertAtBegin(last, 20);
last = insertAtBegin(last, 10);
last = insertAtEnd(last, 40);
last = insertAtEnd(last, 60);
last = insertAfter(last, 50,40 );
cout<<“The circular linked list created is as follows:”<<endl;
traverseList(last);
deleteNode(&last,10);
return 0;
Output:
Thecircularlinkedlistcreatedisasfollows:
10==>20==>30==>40==>50==>60==>10
The node with data 10 is deleted from the list
Circularlinkedlistafterdeleting10isasfollows:
20==>30==>40==>50==>60==>20
Next, we present a Java implementation for the Circular linked list operations.
//Java class to demonstrate circular linked list operations
class Main
{
static class Node
int data;
Node next;
;
//insert a new node in the empty list
static Node insertInEmpty(Node last, int new_data)
// if list is not empty, return
if (last != null)
return last;
Node temp = new Node(); // create a new node
temp.data = new_data; // assign data to new node
last = temp;
last.next = last; // Create the link
return last;
//insert a new node the beginning of the list
static Node insertAtBegin(Node last, int new_data)
//if list is null, then return and call funciton to insert node in empty list
if (last == null)
return insertInEmpty(last, new_data);
//create a new node
Node temp = new Node();
//set data for the node
temp.data = new_data;
temp.next = last.next;
last.next = temp;
return last;
//insert a new node the end of the list
static Node insertAtEnd(Node last, int new_data)
//if list is null, then return and call funciton to insert node in empty list
if (last == null)
return insertInEmpty(last, new_data);
//create a new node
Node temp = new Node();
temp.data = new_data;
temp.next = last.next;
last.next = temp;
last = temp;
return last;
//insert node in between the nodes in the list
static Node addAfter(Node last, int new_data, int after_item)
{
//if list is null, return
if (last == null)
return null;
Node temp, p.;
p. = last.next;
do
if (p..data == after_item)
temp = new Node();
temp.data = new_data;
temp.next = p..next;
p..next = temp;
if (p. == last)
last = temp;
return last;
p. = p..next;
while(p. != last.next);
System.out.println(“The node with data ” + after_item + ” not present in the list.”);
return last;
//traverse the circular linked list
static void traverse(Node last)
Node p.;
// If list is empty, return.
if (last == null)
System.out.println(“Cicular linked List is empty.”);
return;
p. = last.next; // Point to first Node of the list.
// Traversing the list.
do
System.out.print(p..data + “==>”);
p. = p..next;
while(p. != last.next);
if(p. == last.next)
System.out.print(p..data);
System.out.print(“nn”);
//delete a node from the list
static Node deleteNode(Node head, int key)
//if list is null, return
if (head == null)
return null;
// Find the required node that is to be deleted
Node curr = head, prev = new Node();
while (curr.data != key)
if (curr.next == head)
System.out.printf(“nGiven node ” + key + ” is not found” + in the list!”);
break;
prev = curr;
curr = curr.next;
// Check if node is only node
if (curr.next == head)
head = null;
return head;
// If more than one node, check if it is first node
if (curr == head)
prev = head;
while (prev.next != head)
prev = prev.next;
head = curr.next;
prev.next = head;
// check if node is last node
else if (curr.next == head)
prev.next = head;
else
prev.next = curr.next;
System.out.println(“After deleting ” + key + ” the circular list is:”);
traverse(head);
return head;
// Main code
public static void main(String[] args)
Node last = null;
last = insertInEmpty(last, 30);
last = insertAtBegin(last, 20);
last = insertAtBegin(last, 10);
last = insertAtEnd(last, 40);
last = insertAtEnd(last, 60);
last = addAfter(last, 50, 40);
System.out.println(“Circular linked list created is:”);
traverse(last);
last = deleteNode(last,40);
Output:
Circularlinkedlistcreatedis:
10==>20==>30==>40==>50==>60==>10
Afterdeleting40thecircularlistis:
10==>20==>30==>50==>60==>10
Advantages/Disadvantages
Let us discuss some advantages and disadvantages of the circular linked list.
Advantages:
- We can go to any node and traverse from any node. We just need to stop when we visit the same node again.As the last node points to the first node, going to the first node from the last node just takes a single step.
Disadvantages:
- Reversing a circular linked list is cumbersome.As the nodes are connected to form a circle, there is no proper marking for beginning or end for the list. Hence, it is difficult to find the end of the list or loop control. If not taken care, an implementation might end up in an infinite loop.We cannot go back to the previous node in a single step. We have to traverse the entire list from first.
Applications Of Circular Linked List
- Real-time application of circular linked list can be a multi-programming operating system wherein it schedules multiple programs. Each program is given a dedicated timestamp to execute after which the resources are passed to another program. This goes on continuously in a cycle. This representation can be efficiently achieved using a circular linked list.Games that are played with multiple players can also be represented using a circular linked list in which each player is a node that is given a chance to play.We can use a circular linked list to represent a circular queue. By doing this, we can remove the two pointers front and rear that is used for the queue. Instead, we can use only one pointer.
Conclusion
A circular linked list is a collection of nodes in which the nodes are connected to each other to form a circle. This means instead of setting the next pointer of the last node to null, it is linked to the first node.
A circular linked list is helpful in representing structures or activities which need to be repeated again and again after a specific time interval like programs in a multiprogramming environment. It is also beneficial for designing a circular queue.
Circular linked lists tư vấn various operations like insertion, deletion, and traversals. Thus we have seen the operations in detail in this tutorial.
In our next topic on data structures, we will learn about the stack data structure.
=> Check Here To See A-Z Of C++ Training Tutorials Here.
Recommended Reading
- Linked List Data Structure In C++ With IllustrationDoubly Linked List Data Structure In C++ With IllustrationQueue Data Structure In C++ With IllustrationStack Data Structure In C++ With IllustrationPriority Queue Data Structure In C++ With IllustrationTop 15 Best Free Data Mining Tools: The Most Comprehensive ListIntroduction To Data Structures In C++15 Best ETL Tools in 2022 (A Complete Updated List)
Reply
6
0
Chia sẻ
Video Circular linked list example ?
Bạn vừa Read tài liệu Với Một số hướng dẫn một cách rõ ràng hơn về Review Circular linked list example tiên tiến và phát triển nhất
Share Link Cập nhật Circular linked list example miễn phí
Hero đang tìm một số trong những Chia Sẻ Link Cập nhật Circular linked list example Free.
Thảo Luận vướng mắc về Circular linked list example
Nếu You sau khi đọc nội dung bài viết Circular linked list example , bạn vẫn chưa hiểu thì hoàn toàn có thể lại Comments ở cuối bài để Mình lý giải và hướng dẫn lại nha
#Circular #linked #list