Summary  
Describes how to dynamically create and insert nodes into a singly linked list by allocating memory and updating head and next pointers, handling both empty and non-empty list cases.  

General domain of usage  
Data structures and algorithms

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á esses nós e os integrará para que a lista cresça dinamicamente à medida que elementos são adicionados.

Essa abordagem prática ajuda a compreender exatamente o que acontece nos bastidores.

## Implementação da Inserção de Nós

Vamos escrever uma função simples para criar um nó. Essa 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**), basta atualizar 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ó head).
No caso de uma lista não vazia, utiliza-se um loop para procurar o último nó.

O nó atual atua como um nó buffer, permitindo iterar pela lista e encontrar um nó que não aponta para nenhum outro (**\*next == NULL**).



```
struct Node* current = *head;

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

Ao final, é 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ó da lista.

Como tarefa, é preciso identificar e adicionar uma função para inserir novos nós em nós já 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 de como structs funcionam em C, desde definições básicas até conceitos avançados de memória. Explore como ponteiros interagem com dados estruturados, descubra maneiras eficientes de organizar informações e desenvolva confiança implementando estruturas de dados reais, como listas encadeadas.

Explore os fundamentos de structs, compreenda por que são utilizados e desenvolva confiança ao definir, criar e acessar dados estruturados.

Descubra como ponteiros interagem com structs, entenda por que essa conexão é importante e domine técnicas essenciais como alocação dinâmica e passagem de structs para funções

Adquira uma compreensão sólida de como structs são armazenados na memória, explore alinhamento e preenchimento, e aprenda como unions auxiliam no gerenciamento eficiente de dados compartilhados.

Aprofunde-se em padrões avançados de structs, incluindo structs aninhadas e anônimas, explore maneiras práticas de combiná-las com arrays e familiarize-se com estruturas de dados comuns.

Desenvolvimento de confiança por meio da implementação de uma lista ligada do zero, exploração de sua estrutura e criação de funções essenciais para adicionar, percorrer e gerenciar elementos da lista.

Adicionando Elementos

Implementação da Inserção de Nós

Solução