Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • DSA
  • Practice Bitwise Algorithms
  • MCQs on Bitwise Algorithms
  • Tutorial on Biwise Algorithms
  • Binary Representation
  • Bitwise Operators
  • Bit Swapping
  • Bit Manipulation
  • Count Set bits
  • Setting a Bit
  • Clear a Bit
  • Toggling a Bit
  • Left & Right Shift
  • Gray Code
  • Checking Power of 2
  • Important Tactics
  • Bit Manipulation for CP
  • Fast Exponentiation
Open In App
Next Article:
XOR Linked List - Reversal of a List
Next article icon

XOR Linked List: Remove last node of the Linked List

Last Updated : 06 Mar, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an XOR linked list, the task is to delete the node at the end of the XOR Linked List.

Examples:

Input: 4<–>7<–>9<–>7
Output: 4<–>7<–>9
Explanation: Deleting a node from the end modifies the given XOR Linked List to 4<–>7<–>9

Input: 10
Output: List is empty
Explanation: After deleting the only node present in the XOR Linked List, the list becomes empty.

Approach: The idea to solve this problem is to traverse the XOR linked list until the last node is reached and update the address of its previous node. Follow the steps below to solve the problem:

  • If the XOR linked list is empty, then print "List is empty".
  • Traverse the XOR Linked List until the last node of the Linked List is reached.
  • Update the address of its previous node.
  • Delete the last node from memory.
  • If the list becomes empty after deleting the last node, then print "List is empty". Otherwise, print the remaining nodes of the linked list.

Below is the implementation of the above approach:

C++
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;  // Structure of a node in XOR linked list struct Node  {        // Stores data value of a node     int data;        // Stores XOR of previous pointer and next pointer     struct Node* nxp; };  // Function to find the XOR of two nodes struct Node* XOR(struct Node* a, struct Node* b) {     return (struct Node*)((uintptr_t)(a) ^ (uintptr_t)(b)); }  // Function to insert a node with given value at given position struct Node* insert(struct Node** head, int value) {        // If XOR linked list is empty     if (*head == NULL)     {                // Initialize a new Node         struct Node* node = new Node;                // Stores data value in the node         node->data = value;                // Stores XOR of previous and next pointer         node->nxp = XOR(NULL, NULL);                // Update pointer of head node         *head = node;     }      // If the XOR linked list is not empty     else      {                // Stores the address of current node         struct Node* curr = *head;                // Stores the address of previous node         struct Node* prev = NULL;                // Initialize a new Node         struct Node* node = new Node;                // Update curr node address         curr->nxp = XOR(node, XOR(NULL, curr->nxp));                // Update new node address         node->nxp = XOR(NULL, curr);                // Update head         *head = node;                // Update data value of current node         node->data = value;     }     return *head; }  // Function to print elements of the XOR Linked List void printList(struct Node** head) {     // Stores XOR pointer in current node     struct Node* curr = *head;        // Stores XOR pointer of in previous Node     struct Node* prev = NULL;     // Stores XOR pointer of in next node     struct Node* next;     // Traverse XOR linked list     while (curr != NULL) {         // Print current node         cout << curr->data << " ";         // Forward traversal         next = XOR(prev, curr->nxp);         // Update prev         prev = curr;         // Update curr         curr = next;     } }  // Function to delete the last node present in the XOR Linked List struct Node* delEnd(struct Node** head) {     // Base condition     if (*head == NULL)         cout << "List is empty";     else      {                // Stores XOR pointer in current node         struct Node* curr = *head;                // Stores XOR pointer of in previous Node         struct Node* prev = NULL;                // Stores XOR pointer of in next node         struct Node* next;                // Traverse XOR linked list         while (XOR(curr->nxp, prev) != NULL)         {             // Forward traversal             next = XOR(prev, curr->nxp);                        // Update prev             prev = curr;                        // Update curr             curr = next;         }         // If the Linked List contains more than 1 node         if (prev != NULL) {             prev->nxp = XOR(XOR(prev->nxp, curr), NULL);         }         // Otherwise         else {             *head = NULL;         }          // Delete the last node from memory         delete(curr);     }      // Returns head of new linked list     return *head; }  // Driver Code int main() {      /* Create the XOR Linked List     head-->40<-->30<-->20<-->10 */     struct Node* head = NULL;     insert(&head, 10);     insert(&head, 20);     insert(&head, 30);     insert(&head, 40);      delEnd(&head);      // If the list had a single node     if (head == NULL)         cout << "List is empty";     else         // Print the list after deletion         printList(&head);      return (0); }  // This code is contributed by ajaymakvana 
C
// C program for the above approach  #include <inttypes.h> #include <stdio.h> #include <stdlib.h>  // Structure of a node // in XOR linked list struct Node {      // Stores data value     // of a node     int data;      // Stores XOR of previous     // pointer and next pointer     struct Node* nxp; };  // Function to find the XOR of two nodes struct Node* XOR(struct Node* a, struct Node* b) {     return (struct Node*)((uintptr_t)(a)                           ^ (uintptr_t)(b)); }  // Function to insert a node with // given value at given position struct Node* insert(struct Node** head, int value) {     // If XOR linked list is empty     if (*head == NULL) {          // Initialize a new Node         struct Node* node             = (struct Node*)malloc(                 sizeof(struct Node));          // Stores data value in         // the node         node->data = value;          // Stores XOR of previous         // and next pointer         node->nxp = XOR(NULL, NULL);          // Update pointer of head node         *head = node;     }      // If the XOR linked list     // is not empty     else {          // Stores the address         // of current node         struct Node* curr = *head;          // Stores the address         // of previous node         struct Node* prev = NULL;          // Initialize a new Node         struct Node* node             = (struct Node*)malloc(                 sizeof(struct Node));          // Update curr node address         curr->nxp = XOR(node,                         XOR(NULL, curr->nxp));          // Update new node address         node->nxp = XOR(NULL, curr);          // Update head         *head = node;          // Update data value of         // current node         node->data = value;     }     return *head; }  // Function to print elements of // the XOR Linked List void printList(struct Node** head) {     // Stores XOR pointer     // in current node     struct Node* curr = *head;      // Stores XOR pointer of     // in previous Node     struct Node* prev = NULL;      // Stores XOR pointer of     // in next node     struct Node* next;      // Traverse XOR linked list     while (curr != NULL) {          // Print current node         printf("%d ", curr->data);          // Forward traversal         next = XOR(prev, curr->nxp);          // Update prev         prev = curr;          // Update curr         curr = next;     } }  // Function to delete the last node // present in the XOR Linked List struct Node* delEnd(struct Node** head) {     // Base condition     if (*head == NULL)         printf("List is empty");     else {          // Stores XOR pointer         // in current node         struct Node* curr = *head;          // Stores XOR pointer of         // in previous Node         struct Node* prev = NULL;          // Stores XOR pointer of         // in next node         struct Node* next;          // Traverse XOR linked list         while (XOR(curr->nxp, prev) != NULL) {              // Forward traversal             next = XOR(prev, curr->nxp);              // Update prev             prev = curr;              // Update curr             curr = next;         }         // If the Linked List contains more than 1 node         if (prev != NULL)             prev->nxp = XOR(XOR(prev->nxp, curr), NULL);          // Otherwise         else             *head = NULL;          // Delete the last node from memory         free(curr);     }      // Returns head of new linked list     return *head; }  // Driver Code int main() {      /* Create the XOR Linked List     head-->40<-->30<-->20<-->10 */     struct Node* head = NULL;     insert(&head, 10);     insert(&head, 20);     insert(&head, 30);     insert(&head, 40);      delEnd(&head);      // If the list had a single node     if (head == NULL)         printf("List is empty");     else         // Print the list after deletion         printList(&head);      return (0); } 
Java
// Java program for the above approach import java.util.*;  // Structure of a node in XOR linked list class Node {     int value;     int npx;      // Constructor to initialize node     Node(int value)     {         this.value = value;         this.npx = 0;     } }  // create linked list class class XorLinkedList {      Node head;     Node tail;     List<Node> nodes;      // constructor     XorLinkedList()     {         this.head = null;         this.tail = null;         this.nodes = new ArrayList<>();     }      // Function to insert a node with given value at given     // position     void insert(int value)     {         // Initialize a new Node         Node node = new Node(value);          // Check If XOR linked list is empty         if (head == null) {             // Update pointer of head node             head = node;             // Update pointer of tail node             tail = node;         }         else {             // Update curr node address             head.npx = node.hashCode() ^ head.npx;              // Update new node address             node.npx = head.hashCode();              // Update head             head = node;         }         // push node         nodes.add(node);     }      // Function to print elements of the XOR Linked List     void printList()     {         if (head != null) {             int prevId = 0;             Node node = head;             int nextId = 1;             System.out.print(node.value + " ");              // Traverse XOR linked list             while (nextId != 0) {                 // Forward traversal                 nextId = prevId ^ node.npx;                  if (nextId != 0) {                     // Update prev                     prevId = node.hashCode();                      // Update curr                     node = typeCast(nextId);                      // Print current node                     System.out.print(node.value + " ");                 }                 else {                     return;                 }             }         }     }      // method to check if the linked list is empty or not     boolean isEmpty() { return head == null; }      // method to return a new instance of type     Node typeCast(int id)     {         for (Node n : nodes) {             if (n.hashCode() == id) {                 return n;             }         }         return null;     }      // Function to delete the last node present in the XOR     // Linked List     int delEnd()     {         // If list is empty         if (isEmpty()) {             return -1; // Return -1 indicating list is empty         }         // If list has 1 node         else if (head == tail) {             int value = head.value;             head = tail = null;             return value;         }         // If list has 2 nodes         else if (typeCast(0 ^ head.npx) == tail) {             int value = head.value;             tail = head;             head.npx = tail.npx = 0;             return value;         }         // If list has more than 2 nodes         else {             // Stores XOR pointer of in previous Node             int prevId = 0;              // Stores XOR pointer in current node             Node node = head;              // Stores XOR pointer of in next node             int nextId = 1;              // Traverse XOR linked list             while (nextId != 0) {                 // Forward traversal                 nextId = prevId ^ node.npx;                 if (nextId != 0) {                     // Update prev                     prevId = node.hashCode();                      // Update curr                     node = typeCast(nextId);                 }             }             // update res, x, y, and tail.             int res = node.value;             int x = typeCast(prevId).npx ^ node.hashCode();             Node y = typeCast(prevId);             y.npx = x ^ 0;             tail = y;             return res;         }     } }  public class GFG {      // Driver code     public static void main(String[] args)     {         // Create following XOR Linked List         // head-->40<-->30<-->20<-->10         XorLinkedList head = new XorLinkedList();         head.insert(10);         head.insert(20);         head.insert(30);         head.insert(40);          // Delete the first node         head.delEnd();          // Print the following XOR Linked List         // head-->30<-->20<-->10         if (head.isEmpty()) {             System.out.println("List is empty");         }         else {             // Print the list after deletion             head.printList();         }     } }  // This code is contributed by Susobhan Akhuli 
C#
// C# program for the above approach using System; using System.Collections.Generic;  // Structure of a node in XOR linked list class Node {     public int value;     public int npx;      // Constructor to initialize node     public Node(int value)     {         this.value = value;         this.npx = 0;     } }  // Class for XOR linked list class XorLinkedList {     private Node head;     private Node tail;     private List<Node> nodes;      // Constructor     public XorLinkedList()     {         head = null;         tail = null;         nodes = new List<Node>();     }      // Function to insert a node with given value at the     // beginning     public void Insert(int value)     {         Node node = new Node(value);         if (head == null) {             head = node;             tail = node;         }         else {             head.npx = node.GetHashCode() ^ head.npx;             node.npx = head.GetHashCode();             head = node;         }         nodes.Add(node);     }      // Function to print elements of the XOR Linked List     public void PrintList()     {         if (head != null) {             int prevId = 0;             Node node = head;             int nextId = 1;             Console.Write(node.value + " ");             while (nextId != 0) {                 nextId = prevId ^ node.npx;                 if (nextId != 0) {                     prevId = node.GetHashCode();                     node = TypeCast(nextId);                     Console.Write(node.value + " ");                 }                 else {                     return;                 }             }         }     }      // Method to check if the linked list is empty     public bool IsEmpty() { return head == null; }      // Method to return a new instance of type Node     private Node TypeCast(int id)     {         foreach(Node n in nodes)         {             if (n.GetHashCode() == id) {                 return n;             }         }         return null;     }      // Function to delete the last node present in the XOR     // Linked List     public int DelEnd()     {         if (IsEmpty()) {             return -1; // Return -1 indicating list is empty         }         else if (head == tail) {             int value = head.value;             head = tail = null;             return value;         }         else if (TypeCast(0 ^ head.npx) == tail) {             int value = head.value;             tail = head;             head.npx = tail.npx = 0;             return value;         }         else {             int prevId = 0;             Node node = head;             int nextId = 1;             while (nextId != 0) {                 nextId = prevId ^ node.npx;                 if (nextId != 0) {                     prevId = node.GetHashCode();                     node = TypeCast(nextId);                 }             }             int res = node.value;             int x                 = TypeCast(prevId).npx ^ node.GetHashCode();             Node y = TypeCast(prevId);             y.npx = x ^ 0;             tail = y;             return res;         }     } }  public class GFG {     // Driver code     public static void Main(string[] args)     {         // Create XOR Linked List: head --> 40 <--> 30 <-->         // 20 <--> 10         XorLinkedList head = new XorLinkedList();         head.Insert(10);         head.Insert(20);         head.Insert(30);         head.Insert(40);          // Delete the first node         head.DelEnd();          // Print XOR Linked List: head --> 30 <--> 20 <-->         // 10         if (head.IsEmpty()) {             Console.WriteLine("List is empty");         }         else {             head.PrintList();         }     } }  // This code is contributed by Susobhan Akhuli 
JavaScript
// Define a class for the Node class Node {     constructor(value) {         this.value = value;         this.npx = 0;     } }  // Define a class for the XOR Linked List class XorLinkedList {     constructor() {         this.head = null;         this.tail = null;         this.nodes = [];     }      // Function to insert a node with given value     insert(value) {         let node = new Node(value);         this.nodes.push(node);         if(this.head === null){             this.tail = node;         }         if (this.head !== null) {             node.npx = getPointer(this.head);             this.head.npx = getPointer(node) ^ this.head.npx;         }         this.head = node;     }      // Function to print elements of the XOR Linked List in the same line     printList() {         let current = this.head;         let prevAddr = null;         let output = ""; // Initialize an empty string for concatenation                  while (current) {             output += current.value + " "; // Concatenate the current value with a space             let nextAddr = prevAddr ^ current.npx;             prevAddr = getPointer(current);             current = dereferencePointer(nextAddr);         }         console.log(output); // Print the concatenated string containing all values     }      // Method to check if the linked list is empty     isEmpty() {         return !this.head;     }              // Function to delete the last node present in the XOR Linked List     delEnd() {         if (this.isEmpty()) {             return -1;         } else if (this.head === this.tail) {             let value = this.head.value;             this.head = this.tail = null;             return value;         } else {             let secLastNodeId = this.nodes[this.nodes.indexOf(this.tail)-1];             var res = this.nodes.shift();             addressMap.delete(this.tail);             delete this.tail;             this.tail = secLastNodeId;             return res;         }     } }  let addressMap = new Map(); let addressCount = 1;   function getPointer(object) {     if (addressMap.has(object)) return addressMap.get(object);       let newAddressCountValue = addressCount++;     addressMap.set(object, newAddressCountValue);       return newAddressCountValue; }   function dereferencePointer(address) {    for (let [key, value] of addressMap.entries()) {        if (value === address) return key;    }    return undefined; }  // Create XOR Linked List let xll = new XorLinkedList();  // Insert elements into XOR Linked List // 40->30->20->10 xll.insert(10); xll.insert(20); xll.insert(30); xll.insert(40);  // Delete the last node xll.delEnd();  // Print the XOR Linked List if (xll.isEmpty()) {     console.log("List is empty"); } else {     // Print the list after deletion     xll.printList(); }  // This code is contributed by Susobhan Akhuli 
Python3
# Python implementation of the above approach.  import ctypes   # Structure of a node in XOR linked list class Node:          def __init__(self, value):         self.value = value         self.npx = 0   # create linked list class class XorLinkedList:       # constructor     def __init__(self):         self.head = None         self.tail = None         self.__nodes = []                   # Function to insert a node with given value at given position     def insert(self, value):                  # Initialize a new Node         node = Node(value)                  # Check If XOR linked list is empty         if self.head is None:                          # Update pointer of head node             self.head = node                          # Update pointer of tail node             self.tail = node                      else:                          # Update curr node address             self.head.npx = id(node) ^ self.head.npx                          # Update new node address             node.npx = id(self.head)                          # Update head             self.head = node                      # push node         self.__nodes.append(node)                   # Function to print elements of the XOR Linked List     def printList(self):                    if self.head != None:             prev_id = 0             node = self.head             next_id = 1             print(node.value, end=' ')                          # Traverse XOR linked list             while next_id:                                  # Forward traversal                 next_id = prev_id ^ node.npx                                  if next_id:                                          # Update prev                     prev_id = id(node)                                          # Update curr                     node = self.__type_cast(next_id)                                          # Print current node                     print(node.value, end=' ')                 else:                     return                       # method to check if the linked list is empty or not     def isEmpty(self):         if self.head is None:             return True         return False          # method to return a new instance of type     def __type_cast(self, id):         return ctypes.cast(id, ctypes.py_object).value               # Function to delete the last node present in the XOR Linked List     def delEnd(self):                  # If list is empty         if self.isEmpty():               return "List is empty !"                  # If list has 1 node         elif self.head == self.tail:              self.head = self.tail = None                  # If list has 2 nodes         elif self.__type_cast(0 ^ self.head.npx) == (self.tail):              self.tail = self.head             self.head.npx = self.tail.npx = 0                      # If list has more than 2 nodes          else:               # Stores XOR pointer of in previous Node             prev_id = 0                          # Stores XOR pointer in current node             node = self.head                          # Stores XOR pointer of in next node             next_id = 1                          # Traverse XOR linked list             while next_id:                                  # Forward traversal                 next_id = prev_id ^ node.npx                 if next_id:                                          # Update prev                     prev_id = id(node)                                          # Update curr                     node = self.__type_cast(next_id)                                  # update res, x, y, and tail.                           res = node.value             x = self.__type_cast(prev_id).npx ^ id(node)             y = self.__type_cast(prev_id)             y.npx = x ^ 0             self.tail = y             return res           # Create following XOR Linked List # head-->40<-->30<-->20<-->10  head = XorLinkedList() head.insert(10) head.insert(20) head.insert(30) head.insert(40)  # Delete the first node head.delEnd();   # Print the following XOR Linked List # head-->30<-->20<-->10  if (head == None):     print("List is empty") else:     # Print the list after deletion     head.printList();   # This code is contributed by Nighi goel. 

Output
40 30 20 

Time Complexity: O(N)
Auxiliary Space: O(1)


Next Article
XOR Linked List - Reversal of a List

D

debarpan_bose_chowdhury
Improve
Article Tags :
  • Linked List
  • Bit Magic
  • DSA
  • Linked Lists
  • Bitwise-XOR
Practice Tags :
  • Bit Magic
  • Linked List

Similar Reads

  • XOR linked list- Remove first node of the linked list
    Given an XOR linked list, the task is to remove the first node of the XOR linked list. Examples: Input: XLL = 4 < – > 7 < – > 9 < – > 7 Output: 7 < – > 9 < – > 7 Explanation: Removing the first node of the XOR linked list modifies XLL to 7 < – > 9 < – > 7 In
    11 min read
  • XOR linked list: Reverse last K nodes of a Linked List
    Given a XOR Linked List and a positive integer K, the task is to reverse the last K nodes in the given XOR linked list. Examples: Input: LL: 7 <–> 6 <–> 8 <–> 11 <–> 3 <–> 1, K = 3Output: 7<–>6<–>8<–>1<–>3<–>11 Input: LL: 7 <–> 6 <
    14 min read
  • XOR Linked List - Reversal of a List
    Given a XOR linked list, the task is to reverse the XOR linked list. Examples: Input: 4 <–> 7 <–> 9 <–> 7Output: 7 <–> 9 <–> 7 <–> 4Explanation:Reversing the linked list modifies the XOR linked list to 7 <–> 9 <–> 7 <–> 4. Input: 2 <-> 5
    12 min read
  • Remove Nth node from end of the Linked List
    Given a linked list. The task is to remove the Nth node from the end of the linked list. Examples: Input : LinkedList = 1 ->2 ->3 ->4 ->5 , N = 2Output : 1 ->2 ->3 ->5Explanation: Linked list after deleting the 2nd node from last which is 4, is 1 ->2 ->3 ->5 Input : Lin
    15+ min read
  • Remove all occurrences of one Linked list in another Linked list
    Given two linked lists head1 and head2, the task is to remove all occurrences of head2 in head1 and return the head1. Examples: Input: head1 = 2 -> 3 -> 4 -> 5 -> 3 -> 4, head2 = 3 -> 4Output: 2 -> 5Explanation: After removing all occurrences of 3 -> 4 in head1 output is 2 -
    9 min read
  • Convert Singly Linked List to XOR Linked List
    Prerequisite: XOR Linked List – A Memory Efficient Doubly Linked List | Set 1XOR Linked List – A Memory Efficient Doubly Linked List | Set 2 An XOR linked list is a memory efficient doubly linked list in which the next pointer of every node stores the XOR of previous and next node's address. Given a
    9 min read
  • XOR Linked List - Find the middle node
    Given an XOR linked list, the task is to find the middle node of the given XOR linked list. Examples: Input: 4 –> 7 –> 5 Output: 7 Explanation: The middle node of the given XOR list is 7. Input: 4 –> 7 –> 5 –> 1 Output: 7 5 Explanation: The two middle nodes of the XOR linked list with
    14 min read
  • Insert node into the middle of the linked list
    Given a linked list containing n nodes. The problem is to insert a new node with data x in the middle of the list. If n is even, then insert the new node after the (n/2)th node, else insert the new node after the (n+1)/2th node. Examples: Input: LinkedList = 1->2->4 , x = 3Output: 1->2->
    15 min read
  • Insert Node at the End of a Linked List
    Given a linked list, the task is to insert a new node at the end of the linked list. Examples: Input: LinkedList = 2 -> 3 -> 4 -> 5, NewNode = 1Output: LinkedList = 2 -> 3 -> 4 -> 5 -> 1 Input: LinkedList = NULL, NewNode = 1Output: LinkedList = 1 Approach:  Inserting at the end
    9 min read
  • Remove the common nodes in two Singly Linked Lists
    Given two Linked Lists L1 and L2, the task is to generate a new linked list with no common elements from the given two linked lists. Example: Input: L1 = 10 -> 15 -> 5 -> 20, L2 = 8 -> 5 -> 20 -> 10 Output: 8 -> 15 Explanation: Since both the linked list has 5, 10 and 20 in comm
    10 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences