What are some examples of linked lists in C++?

What are some examples of linked lists in C++?

In C++, a linked list is a data structure consisting of nodes, where each node contains data and a pointer to the next node. Here are a few examples:

1. Singly Linked List: Each node points to the next node, and the last node points to null.
2. Doubly Linked List: Each node has pointers to both the next and the previous nodes.
3. Circular Linked List: The last node points back to the first node, forming a circle.

Can you show me a simple implementation of a singly linked list?

Sure! Here's a simple implementation of a singly linked list in C++:

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

class SinglyLinkedList {
private:
    Node* head;
public:
    SinglyLinkedList() : head(nullptr) {}

    void insert(int val) {
        Node* newNode = new Node(val);
        if (!head) {
            head = newNode;
        } else {
            Node* temp = head;
            while (temp->next) {
                temp = temp->next;
            }
            temp->next = newNode;
        }
    }

    void display() {
        Node* temp = head;
        while (temp) {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
};

int main() {
    SinglyLinkedList list;
    list.insert(1);
    list.insert(2);
    list.insert(3);
    list.display(); // Output: 1 2 3
    return 0;
}

This code defines a simple singly linked list with insert and display methods.

What are the advantages of using linked lists over arrays?

Linked lists have several advantages over arrays:

1. Dynamic Size: Linked lists can grow and shrink in size dynamically, while arrays have a fixed size.
2. Efficient Insertions/Deletions: Inserting or deleting nodes in a linked list can be done in constant time if the position is known, whereas arrays require shifting elements.
3. Memory Utilization: Linked lists can utilize memory more efficiently, as they allocate memory as needed, unlike arrays which may allocate more than necessary.