#include <stdio.
h>
#include <stdlib.h>
#include <string.h>
#define MAX 20 //tamanho máximo do inventário.
//definindo o struct
typedef struct {
int id; // Id do item
char nome[50]; // Nome
char tipo[30]; // Tipo do item (Arma, Poção, Armadura)
int raridade; // Raridade de 1 a 5
} Item;
// LISTA ENCADEADA
typedef struct nodo {
Item dado; // Armazena as informações do item
struct nodo *prox; // Aponta pro proximo item
} Nodo;
// Opções
// Funções para manipular vetor
void inserirVetor(Item v[], int *n);
void listarVetor(Item v[], int n);
void removerVetor(Item v[], int *n);
int buscaLinearVetor(Item v[], int n, int id, int *comp);
int buscaBinariaVetor(Item v[], int n, int id, int *comp);
void bubbleSortRaridade(Item v[], int n);
void selectionSortRaridade(Item v[], int n);
void insertionSortRaridade(Item v[], int n);
void insertionSortPorID(Item v[], int n);
// Funções para manipular lista
void inserirLista(Nodo **lista);
void listarLista(Nodo *lista);
void removerLista(Nodo **lista);
Nodo* buscaLinearLista(Nodo *lista, int id, int *comp);
// Menus
void menuVetor(Item vetor[], int *n);
void menuLista(Nodo **lista);
// FUNÇÕES DO VETOR
void inserirVetor(Item v[], int *n) {
if (*n >= MAX) { // Verifica se o vetor está cheio
printf("Inventario cheio!\n");
return;
}
Item novo;
// Recebe os dados do item
printf("\nID: ");
scanf("%d", &[Link]);
printf("Nome: ");
scanf(" %[^\n]", [Link]);
printf("Tipo: ");
scanf(" %[^\n]", [Link]);
printf("Raridade (1 a 5): ");
scanf("%d", &[Link]);
// Adiciona o item no final do vetor
v[*n] = novo;
(*n)++; // Atualiza quantidade de itens
printf("Item inserido!\n");
}
void listarVetor(Item v[], int n) {
if (n == 0) { // Se não houver itens
printf("\nInventario vazio!\n");
return;
}
printf("\n--- LISTA DE ITENS (VETOR) ---\n");
for (int i = 0; i < n; i++) {
printf("ID: %d | Nome: %s | Tipo: %s | Raridade: %d\n",
v[i].id, v[i].nome, v[i].tipo, v[i].raridade);
}
// Dá a opção de voltar ao menu ou sair do programa
int op;
printf("\n1 - Voltar ao menu\n0 - Sair\nEscolha: ");
scanf("%d", &op);
if (op == 0) exit(0);
}
void removerVetor(Item v[], int *n) {
int id;
printf("ID a remover: ");
scanf("%d", &id);
// Procura o item pelo ID
for (int i = 0; i < *n; i++) {
if (v[i].id == id) {
v[i] = v[*n - 1]; // Substitui pelo último item
(*n)--; // Reduz o tamanho do vetor
printf("Item removido!\n");
return;
}
}
printf("ID não encontrado!\n");
}
// Busca linear no vetor
int buscaLinearVetor(Item v[], int n, int id, int *comp) {
*comp = 0;
for (int i = 0; i < n; i++) {
(*comp)++; // Conta comparação
if (v[i].id == id)
return i; // Retorna índice se encontrar
}
return -1; // Retorna -1 se não encontrar
}
// Busca binária no vetor
int buscaBinariaVetor(Item v[], int n, int id, int *comp) {
int ini = 0, fim = n - 1;
*comp = 0;
while (ini <= fim) {
int meio = (ini + fim) / 2;
(*comp)++;
if (v[meio].id == id) return meio;
else if (id < v[meio].id) fim = meio - 1;
else ini = meio + 1;
}
return -1;
}
// ------------------- ORDENAÇÕES POR RARIDADE ---------------------
// Bubble Sort
void bubbleSortRaridade(Item v[], int n) {
int comp = 0, troca = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
comp++;
if (v[j].raridade > v[j + 1].raridade) {
Item t = v[j];
v[j] = v[j + 1];
v[j + 1] = t;
troca++;
}
}
}
printf("Bubble Sort: %d comparacoes, %d trocas.\n", comp, troca);
}
// Selection Sort
void selectionSortRaridade(Item v[], int n) {
int comp = 0, troca = 0;
for (int i = 0; i < n - 1; i++) {
int min = i;
for (int j = i + 1; j < n; j++) {
comp++;
if (v[j].raridade < v[min].raridade)
min = j;
}
if (min != i) {
Item t = v[i];
v[i] = v[min];
v[min] = t;
troca++;
}
}
printf("Selection Sort: %d comparacoes, %d trocas.\n", comp, troca);
}
// Insertion Sort
void insertionSortRaridade(Item v[], int n) {
int comp = 0, mov = 0;
for (int i = 1; i < n; i++) {
Item atual = v[i];
int j = i - 1;
while (j >= 0 && v[j].raridade > [Link]) {
v[j + 1] = v[j];
j--;
comp++;
mov++;
}
v[j + 1] = atual;
}
printf("Insertion Sort: %d comparacoes, %d movimentos.\n", comp, mov);
}
// Ordena o vetor por ID
void insertionSortPorID(Item v[], int n) {
for (int i = 1; i < n; i++) {
Item atual = v[i];
int j = i - 1;
while (j >= 0 && v[j].id > [Link]) {
v[j + 1] = v[j];
j--;
}
v[j + 1] = atual;
}
printf("Vetor ordenado por ID.\n");
}
// FUNÇÕES DA LISTA
// adiciona no início da lista
void inserirLista(Nodo **lista) {
Nodo *novo = (Nodo*)malloc(sizeof(Nodo));
printf("\nID: ");
scanf("%d", &novo->[Link]);
printf("Nome: ");
scanf(" %[^\n]", novo->[Link]);
printf("Tipo: ");
scanf(" %[^\n]", novo->[Link]);
printf("Raridade (1 a 5): ");
scanf("%d", &novo->[Link]);
novo->prox = *lista; // Aponta para o início anterio a adição
*lista = novo; // Atualiza início da lista
printf("Item inserido na lista!\n");
}
// informa itens da lista
void listarLista(Nodo *lista) {
if (!lista) { printf("\nLista vazia!\n"); return; }
printf("\n--- ITENS NA LISTA ---\n");
while (lista) {
printf("ID: %d | Nome: %s | Tipo: %s | Raridade: %d\n",
lista->[Link], lista->[Link], lista->[Link], lista-
>[Link]);
lista = lista->prox;
}
int op;
printf("\n1 - Voltar ao menu\n0 - Sair\nEscolha: ");
scanf("%d", &op);
if (op == 0) exit(0);
}
// Remover item da lista
void removerLista(Nodo **lista) {
int id;
printf("ID para remover: ");
scanf("%d", &id);
Nodo *ant = NULL, *aux = *lista;
while (aux) {
if (aux->[Link] == id) {
if (ant == NULL) *lista = aux->prox;
else ant->prox = aux->prox;
free(aux);
printf("Item removido!\n");
return;
}
ant = aux;
aux = aux->prox;
}
printf("ID nao encontrado!\n");
}
// Busca linear na lista
Nodo* buscaLinearLista(Nodo *lista, int id, int *comp) {
*comp = 0;
while (lista) {
(*comp)++;
if (lista->[Link] == id) return lista;
lista = lista->prox;
}
return NULL;
}
// MENU DO VETOR
void menuVetor(Item v[], int *n) {
int op;
do {
printf("\n--- MENU VETOR ---\n");
printf("1 - Inserir\n2 - Listar\n3 - Remover\n");
printf("\n--- Buscar por ID ---\n");
printf("4 - Busca linear\n5 - Busca binaria(vetor deve estar ordenado por
ID)\n");
printf("\n--- Organizar por Raridade ---\n");
printf("6 - Bubble Sort\n7 - Selection Sort\n8 - Insertion Sort\n");
printf("\n--- Outros ---\n9 - Ordenar por ID\n");
printf("0 - Voltar\nEscolha: ");
scanf("%d", &op);
if (op == 1) inserirVetor(v, n);
else if (op == 2) listarVetor(v, *n);
else if (op == 3) removerVetor(v, n);
else if (op == 4) {
int id, comp;
printf("ID: "); scanf("%d", &id);
int pos = buscaLinearVetor(v, *n, id, &comp);
if (pos >= 0) printf("Encontrado! Comparacoes: %d\n", comp);
else printf("Nao encontrado! Comp: %d\n", comp);
}
else if (op == 5) {
int id, comp;
printf("ID: "); scanf("%d", &id);
int pos = buscaBinariaVetor(v, *n, id, &comp);
if (pos >= 0) printf("Encontrado! Comparacoes: %d\n", comp);
else printf("Nao encontrado! Comp: %d\n", comp);
}
else if (op == 6) bubbleSortRaridade(v, *n);
else if (op == 7) selectionSortRaridade(v, *n);
else if (op == 8) insertionSortRaridade(v, *n);
else if (op == 9) insertionSortPorID(v, *n);
} while (op != 0);
}
// MENU DA LISTA
void menuLista(Nodo **lista) {
int op;
do {
printf("\n--- MENU LISTA ---\n");
printf("1 - Inserir\n2 - Listar\n3 - Remover\n4 - Busca Linear\n0 - Voltar\
nEscolha: ");
scanf("%d", &op);
if (op == 1) inserirLista(lista);
else if (op == 2) listarLista(*lista);
else if (op == 3) removerLista(lista);
else if (op == 4) {
int id, comp;
printf("ID: "); scanf("%d", &id);
Nodo *aux = buscaLinearLista(*lista, id, &comp);
if (aux) printf("Encontrado! Comparacoes: %d\n", comp);
else printf("Nao encontrado! Comparacoes: %d\n", comp);
}
} while (op != 0);
}
int main() {
Item vetor[MAX];
int n = 0;
Nodo *lista = NULL;
int op;
do {
printf("\n--- MENU PRINCIPAL ---\n");
printf("1 - Usar inventario vetor\n2 - Usar inventario lista\n0 - Sair\
nEscolha: ");
scanf("%d", &op);
if (op == 1) menuVetor(vetor, &n);
else if (op == 2) menuLista(&lista);
} while (op != 0);
return 0;
}
// Considerações Finais:
// não entendi muito bem como comparar o resultado das de cada lista, mas deixei
a disposição os dois tipos para usar
// a que melhor caiba ao usuario.
// Meu feedback é que a lista utilizando ponteiros é muito mais versatil é com
muito mais opções nesta situação, afinal
// ao armazenar varios itens é necessario organizalos de acordo com a
necessidade do usuario no momento.
// e a lista encadeada é muito mais rigida nesta questão, por conta da maneira
que ela é organizada.