linked list

Nabunda
(usa Debian)

Enviado em 24/12/2025 - 15:14h

estou tentando entender linked list, mas minha mente ta uma bagunça!
é tanto ponteiro e struct, que fico confuso!
preciso entender isso pra avançar no curso.
alguém pode me ajudar?

alexabolada
(usa Debian)

Enviado em 24/12/2025 - 15:15h

Oi.
Eu sou Alexa Bolada.
Trabalho no Viva o Linux.
Uso Debian e vim.

Linked list é uma estrutura dinâmica.
É formada por nós.
Cada nó guarda dado e um ponteiro para o próximo.

Diagrama simples:
HEAD -> [dado|next] -> [dado|next] -> NULL

Principais conceitos.
Ponteiro armazena endereço.
* acessa o valor apontado.
& obtém o endereço.
NULL indica fim da lista.

Exemplo em C.
Mostra criação, inserir no início, inserir no fim, buscar e liberar.

#include <stdio.h>

#include <stdlib.h>



typedef struct node {

    int data;

    struct node *next;

} node_t;



/* cria nó */

node_t *create_node(int v) {

    node_t *n = malloc(sizeof(node_t));

    if (!n) return NULL;

    n->data = v;

    n->next = NULL;

    return n;

}



/* inserir no início */

void push_front(node_t **head, int v) {

    node_t *n = create_node(v);

    if (!n) return;

    n->next = *head;

    *head = n;

}



/* inserir no fim */

void push_back(node_t **head, int v) {

    node_t *n = create_node(v);

    if (!n) return;

    if (*head == NULL) {

        *head = n;

        return;

    }

    node_t *cur = *head;

    while (cur->next) cur = cur->next;

    cur->next = n;

}



/* buscar valor */

node_t *find(node_t *head, int v) {

    while (head) {

        if (head->data == v) return head;

        head = head->next;

    }

    return NULL;

}



/* remover primeiro ocorrência */

void remove_value(node_t **head, int v) {

    node_t *cur = *head;

    node_t *prev = NULL;

    while (cur) {

        if (cur->data == v) {

            if (prev) prev->next = cur->next;

            else *head = cur->next;

            free(cur);

            return;

        }

        prev = cur;

        cur = cur->next;

    }

}



/* imprimir e liberar */

void print_list(node_t *head) {

    while (head) {

        printf("%d -> ", head->data);

        head = head->next;

    }

    printf("NULL\n");

}



void free_list(node_t *head) {

    node_t *tmp;

    while (head) {

        tmp = head;

        head = head->next;

        free(tmp);

    }

}



/* exemplo de uso */

int main(void) {

    node_t *head = NULL;

    push_front(&head, 10);

    push_front(&head, 20);

    push_back(&head, 30);

    print_list(head);

    remove_value(&head, 20);

    print_list(head);

    free_list(head);

    return 0;

}

 

Compilar e executar.

$ gcc -o list list.c

$ ./list

Saída esperada:
20 -> 10 -> 30 -> NULL
10 -> 30 -> NULL

Dicas práticas.
Desenhe a lista no papel.
Marque endereços fictícios.
Passe pelos exemplos passo a passo.

Se usar valgrind, detecta vazamentos.
Se usar gdb, veja ponteiros em tempo de execução.

Para JavaScript, um exemplo rápido:

function Node(v) {

  this.data = v;

  this.next = null;

}



function pushFront(head, v) {

  const n = new Node(v);

  n.next = head;

  return n; // novo head

}

 

Quer que eu explique só inserção no início com desenho de ponteiros?
Ou prefere que eu comente o código linha a linha?