Summary  
This chapter covers dynamically creating nodes and inserting them into a singly linked list—handling both empty and non-empty lists by allocating memory, traversing via pointers, and updating head and next pointers (using a pointer‐to‐pointer for the head).

General domain of usage  
Data structure implementation

Para tornar sua lista simplesmente encadeada útil, é necessário adicionar nós a ela. Você irá implementar a lógica para inserir nós na lista. Você criará novos nós, conectará eles e os integrará para que a lista cresça dinamicamente à medida que elementos são adicionados.

Essa abordagem prática auxilia na compreensão exata do que ocorre nos bastidores.

## Implementando a Inserção de Nós

Vamos escrever uma função simples para criar um nó. Esta função deve:

- Receber como argumento um número do tipo **int**, que será armazenado no campo data do nó;
- Criar um ponteiro para uma área de memória alocada dinamicamente (considerando o tamanho do nó);
- Verificar o sucesso da alocação de memória para o nó;
- Colocar o valor necessário (argumento da função) no campo data;
- O ponteiro next deve ser **NULL**, já que a função cria apenas um nó;
- A função deve retornar um ponteiro para a área de memória onde o valor está armazenado.

A função **AddNewNode()** recebe um ponteiro para ponteiro, pois pode alterar o valor do ponteiro para o primeiro nó (**head**) da lista, assim como o valor que será armazenado no novo nó:

```
void AddNewNode(struct Node** head, int value) 
{
	...
}
```
Se a lista estiver vazia (**\*head == NULL**), simplesmente atualizamos o ponteiro para o início da lista (**\*head**) para apontar para o novo nó (**newNode**), nesse caso newNode se tornará o primeiro nó (nó cabeça).
No caso de uma lista não vazia, utilizamos um loop para procurar o último nó.

O nó atual atua como um nó buffer, com sua ajuda podemos percorrer a lista e encontrar um nó que não aponta para lugar algum (**\*next == NULL**).



```
struct Node* current = *head;

while (current->next != NULL) 
{
    ...
}
```

Por fim, é necessário tornar o novo nó `newNode` o último nó, o que significa que `current->next` deve ser igual a `newNode`. Agora, newNode é o último nó na lista.

Como tarefa, é necessário identificar e adicionar uma função para adicionar novos nós aos nós existentes.


#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <cstdlib>

struct Node {
    int data;
    struct Node* next;
};

void addNewNode(struct Node** head, int value);

struct Node* createNode(int value);

// Helper function to free the linked list
void freeList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        struct Node* tmp = current;
        current = current->next;
        free(tmp);
    }
}

TEST_CASE("Create a single node") {
    struct Node* node = createNode(42);
    REQUIRE(node != nullptr);
    REQUIRE(node->data == 42);
    REQUIRE(node->next == nullptr);
    free(node);
}

TEST_CASE("Add a node to an empty list") {
    struct Node* head = nullptr;
    addNewNode(&head, 10);

    REQUIRE(head != nullptr);
    REQUIRE(head->data == 10);
    REQUIRE(head->next == nullptr);

    freeList(head);
}

TEST_CASE("Add multiple nodes and check order") {
    struct Node* head = nullptr;
    addNewNode(&head, 10);
    addNewNode(&head, 20);
    addNewNode(&head, 30);

    struct Node* current = head;
    REQUIRE(current->data == 10);
    current = current->next;
    REQUIRE(current->data == 20);
    current = current->next;
    REQUIRE(current->data == 30);
    REQUIRE(current->next == nullptr);

    freeList(head);
}

TEST_CASE("Add negative and zero values") {
    struct Node* head = nullptr;
    addNewNode(&head, 0);
    addNewNode(&head, -5);
    addNewNode(&head, 15);

    struct Node* current = head;
    REQUIRE(current->data == 0);
    current = current->next;
    REQUIRE(current->data == -5);
    current = current->next;
    REQUIRE(current->data == 15);
    REQUIRE(current->next == nullptr);

    freeList(head);
}

TEST_CASE("Add large number of nodes") {
    struct Node* head = nullptr;
    int n = 1000;
    for (int i = 0; i < n; i++) {
        addNewNode(&head, i);
    }

    struct Node* current = head;
    for (int i = 0; i < n; i++) {
        REQUIRE(current != nullptr);
        REQUIRE(current->data == i);
        current = current->next;
    }
    REQUIRE(current == nullptr);

    freeList(head);
}

TEST_CASE("Add to non-empty list preserves previous nodes") {
    struct Node* head = nullptr;
    addNewNode(&head, 1);
    addNewNode(&head, 2);

    addNewNode(&head, 3);
    addNewNode(&head, 4);

    struct Node* current = head;
    REQUIRE(current->data == 1);
    current = current->next;
    REQUIRE(current->data == 2);
    current = current->next;
    REQUIRE(current->data == 3);
    current = current->next;
    REQUIRE(current->data == 4);
    REQUIRE(current->next == nullptr);

    freeList(head);
}

test.cpp

Adquira uma compreensão sólida sobre o funcionamento de structs em C, desde definições básicas até conceitos avançados de memória. Explore como ponteiros interagem com dados estruturados, descubra formas eficientes de organizar informações e desenvolva confiança implementando estruturas de dados reais, como listas encadeadas.

Desenvolva confiança ao implementar uma lista ligada do zero, explore sua estrutura e crie funções essenciais para adicionar, percorrer e gerenciar elementos da lista.

Adicionando Elementos

Implementando a Inserção de Nós

Solução