Trabalho 1 - Algoritmo

Prévia do material em texto

Universidade Estadual de Maringá 
Departamento de Informática 
Disciplina – 7256 
 
 
 
 
 
 
 
Trabalho 1 
 
 
 
 
 
 
 
 
 
Acadêmico: Beatriz Serafim RA: 139858 
 Camila Araujo Laurindo RA: 139239 
Disciplina: Algoritmo e Estrutura de Dados 
Curso: Engenharia de Produção 
Turma: 02 
Professora: Sandra Cossul 
 
 
 
 
 
Maringá, 10 de Julho de 2025. 
 INTRODUÇÃO E JUSTIFICATIVA 
Neste trabalho, temos como objetivo analisar a utilização da lista simplesmente 
encadeada em aplicativos de música. 
Hoje em dia, com o avanço das plataformas de streaming, aplicativos de música 
como o Spotify e o YouTube Music fazem parte da rotina de milhões de pessoas pelo 
mundo. Nesses apps, os usuários podem criar playlists, adicionar e remover música e 
ouvir essas playlists em uma determinada sequência. Para que isso funcione é necessário 
que o sistema utilize alguma, ou algumas, estrutura de dado que permite essas alterações. 
Esse tipo de lista, denominada lista simplesmente encadeada, é formado por 
elementos que se ligam uns aos outros através de ponteiros, o que facilita a inclusão ou 
exclusão de itens, sem que tenha a necessidade de reorganizar toda a estrutura original. 
Isso é útil quando o número de músicas muda com a frequência, como acontece nas 
playlists personalizadas. 
A escolha, desta aplicação se baseia na sua presença constante no cotidiano e na 
capacidade de exemplificar de forma clara os conceitos utilizados na disciplina, como o 
uso de struct, ponteiros e alocação de memória. 
 ESTRUTURA DE DADOS 
Uma lista simplesmente encadeada é uma estrutura formada por nós que apontam 
para o próximo elemento da lista. Cada ponteiro armazena um dado (no caso analisado, 
informações da música) e um ponteiro para o próximo nó. 
Essa estrutura é interessante para aplicativos de música pois permite: 
 Adicionar músicas no fim da playlist; 
 Remover música de qualquer posição; 
 Manter a ordem de execução; 
 Evitar realocação constante de memória. 
Na linguagem C, que é a que usamos em aula, essa estrutura é implementada 
usando struct e monteiros com malloc(). 
 CÓDIGO EM C 
#include 
#include 
 
// Estrutura do nó 
struct Node { 
 char title[100]; // título da música 
 struct Node* next; // ponteiro para a próxima música 
}; 
 
// Cria uma nova música (nó) 
struct Node* newNode(char* title) { 
 struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); 
 strcpy(temp->title, title); 
 temp->next = NULL; 
 return temp; 
} 
 
// Insere música no final da playlist 
void insertEnd(struct Node** head, char* title) { 
 struct Node* nova = newNode(title); 
 if (*head == NULL) { 
 *head = nova; 
 } else { 
 struct Node* temp = *head; 
 while (temp->next != NULL) 
 temp = temp->next; 
 temp->next = nova; 
 } 
} 
 
// Mostra a playlist 
void display(struct Node* head) { 
 struct Node* temp = head; 
 printf("Playlist:\n"); 
 while (temp != NULL) { 
 printf(" - %s\n", temp->title); 
 temp = temp->next; 
 } 
} 
Código adaptado de: https://www.geeksforgeeks.org/c/menu-driven-program-for-all-
operations-on-singly-linked-list-in-c/. 
Ele ilustra claramente a implementação de uma lista simplesmente encadeada, com 
funções de inserção e exibição que podem ser mapeadas padra o uso em uma playlist de 
aplicativo de música. 
 CÓDIGO ADAPTADO 
Como não encontramos um código parecido ao que utilizamos em sala, optei por 
adaptar um dos exemplos que desenvolvemos durante as aulas, ajustando-o para se 
encaixar na aplicação analisada neste trabalho. 
#include 
#include 
 
// Definição da estrutura do nó da lista 
struct elemento { 
 int valor; // Valor armazenado no nó 
 struct elemento *prox; // Ponteiro para o próximo nó 
}; 
 
// Ponteiro global para o início da lista (pode ser usado se necessário) 
struct elemento *inicio = NULL; 
 
/* Cria uma lista vazia (retorna NULL) */ 
struct elemento* cria_lista(void) { 
 return NULL; 
} 
 
/* Verifica se a lista está vazia (retorna 1 se sim, 0 se não) */ 
int lista_vazia(struct elemento *lista) { 
 return (lista == NULL); 
} 
 
/* Insere um novo elemento no final da lista */ 
struct elemento* insere_final(struct elemento *lista) { 
 struct elemento *aux, *novo; 
 int x; 
 
 printf("Entre com um número inteiro: "); 
 scanf("%d", &x); 
 
 // Aloca memória para o novo nó e preenche os dados 
 novo = (struct elemento*) malloc(sizeof(struct elemento)); 
 novo->valor = x; 
 novo->prox = NULL; 
 
 // Se a lista está vazia, o novo nó vira o primeiro 
 if (lista == NULL) { 
 lista = novo; 
 } else { 
 // Caso contrário, percorre até o último e adiciona o novo nó lá 
 aux = lista; 
 while (aux->prox != NULL) { 
 aux = aux->prox; 
 } 
 aux->prox = novo; 
 } 
 
 return lista; 
} 
 
 
/* Exibe todos os elementos da lista */ 
void visualiza_lista(struct elemento *lista) { 
 struct elemento *aux = lista; 
 
 if (lista_vazia(lista)) { 
 printf("Lista vazia!\n"); 
 return; 
 } 
 
 // Percorre a lista e imprime cada valor 
 while (aux != NULL) { 
 printf("Valor da lista: %d\n", aux->valor); 
 aux = aux->prox; 
 } 
} 
 
/* Remove um elemento da lista com o valor especificado */ 
struct elemento* excluir(struct elemento *lista, int valor) { 
 struct elemento *atual = lista; 
 struct elemento *anterior = NULL; 
 
 if (lista_vazia(lista)) { 
 printf("Lista vazia. Nada a excluir.\n"); 
 return lista; 
 } 
 
 // Procura o elemento com o valor desejado 
 while (atual != NULL && atual->valor != valor) { 
 anterior = atual; 
 atual = atual->prox; 
 } 
 
 // Elemento não encontrado 
 if (atual == NULL) { 
 printf("Elemento não encontrado.\n"); 
 return lista; 
 } 
 
 // Se for o primeiro elemento da lista 
 if (anterior == NULL) { 
 lista = atual->prox; 
 } else { 
 // Remove o nó ajustando o ponteiro do anterior 
 anterior->prox = atual->prox; 
 } 
 
 free(atual); // Libera memória do nó removido 
 printf("Elemento removido com sucesso!\n"); 
 
 return lista; 
} 
 
/* Função principal com menu de opções para o usuário */ 
int main() { 
 struct elemento *lista; 
 int op, v; 
 
 lista = cria_lista(); // Inicializa lista vazia 
 
 do { 
 // Exibe o menu de opções 
 printf("\nMenu - Lista Simplesmente Encadeada\n"); 
 printf("1 - Inserir no Final\n"); 
 printf("2 - Visualizar Lista\n"); 
 printf("3 - Excluir Elemento\n"); 
 printf("4 - Sair\n"); 
 printf("Escolha uma opção: "); 
 scanf("%d", &op); 
 
 // Executa a opção escolhida 
 switch (op) { 
 case 1: 
 lista = insere_final(lista); 
 break; 
 case 2: 
 visualiza_lista(lista); 
 break; 
 case 3: 
 printf("Digite o valor a ser removido: "); 
 scanf("%d", &v); 
 lista = excluir(lista, v); 
 break; 
 case 4: 
 printf("Encerrando o programa.\n"); 
 break; 
 default: 
 printf("Opção inválida!\n"); 
 } 
 
 } while (op != 5); // Continua até o usuário escolher sair 
 
 return 0; 
} 
 COMPARAÇÃO COM OS CÓDIGOS DA AULA 
O código desenvolvido para este trabalho apresenta similaridades com os 
exemplos implementados em aula, por se tratar de uma adaptação direta de 
implementaçõespreviamente trabalhadas. Tais semelhanças são evidentes em aspectos 
como: 
 Uso de ponteiros para encadear nós; 
 Criação e manipulação dinâmica com malloc e free; 
 Uso de estrutura (struct) para armazenar múltiplos dados; 
Já as principais adaptações foram: 
 Substituições de tipos simples (como int por char) para armazenar strings; 
 Inclusão de campos específicos da aplicação real (título e artista); 
 A lógica de inserção foi ajustada para inserir sempre no final, simulando a fila de 
execução da playlist. 
 CONCLUSÃO 
O uso da lista simplesmente encadeada em aplicativos de música exemplifica bem 
a flexibilidade dessa estrutura. Através da aplicação prática e do código implementado, é 
possível compreender os conceitos discutidos em sala e visualizar seu uso em situações 
reais.