Estruturas de Dados e Listas

Estrutura de Dados
Sejam bem-vindos!
Bibliografias
Bibliografia Básica:
VETORAZZO, Adriana de Souza; SARAIVA, Maurício de Oliveira; BARRETO, Jeanine dos Santos; JUNIOR, Ramos Estrutura de
Dados. Ed. Grupo A, 2018.
CURY, Thiago Espíndola; BARRETO, Jeanine dos Santos; SARAIVA, Maurício de Oliveira; VETTORAZZO, Adriana de Souza.
Estrutura de Dados. Ed. Grupo A, 2018
PINTO, Rafael Albuquerque. Estrutura de Dados. Ed. Grupo A, 2020.
Bibliografia Complementar:
DROZDEK, Adam. Estrutura de Dados e Algoritmos em C++ – Tradução da 4ª edição norte-americana. Ed. Cengage, 2018.
BIANCHI, Francisco. Estrutura de Dados e Técnicas de Programação. Ed. Grupo GEN, 2014.
KOFFMAN, Elliot B.; WOLFGANG, Paul A. T. Objetos, Abstração, Estrutura de Dados e Projeto Usando C++. Ed. Grupo GEN,
2008.
01/06/2022 fred.lucena@p.ficr.edu.br 3
Tipos Abstratos de Dados
Listas
(Listas)
O que é uma Lista?
É uma coleção de valores, ordenados ou não, armazenados de forma alinhada. As

listas se dividem em:
▪ Fila (FIFO-LILO);
▪ Pilha (FILO-LIFO).
Listas - Fila
(Lista - Fila)
O que é uma Fila?
É um tipo especial de lista, formada por elementos do mesmo tipo, que

comporta as operações de criação, inserção (no fim da lista), remoção (no início
da lista), acesso e destruição. É normalmente utilizado em controle de fluxo, tais
como: fila de impressão; transações de banco de dados; etc.
0 1 2 3 4 5 6 7 8 9
10 20 30
PUSH MAX
(Lista - Fila)
O que é uma Fila?

comporta as operações de criação, inserção (no fim da lista), remoção (no início
da lista), acesso e destruição. É normalmente utilizado em controle de fluxo, tais
como: fila de impressão; transações de banco de dados; etc.
0 1 2 3 4 5 6 7 8 9
10 20 30
MAX
POP
PUSH
Listas - Pilha
(Lista - Pilha)
O que é uma Pilha?

comporta as operações de criação, inserção (no fim da lista), remoção (no fim da
lista), acesso e destruição.
4 MAX
3
PUSH 2
1 20 POP
0 10
(Listas)
Tipos de Alocação de Memória
Alocação Estática:
O espaço de memória é alocado no momento da compilação.
Exige a definição prévia do número máximo de elementos da
lista. A variável vetor é um bom exemplo.
Alocação Dinâmica:
O espaço de memória é alocado em tempo de execução.
Aumenta ou diminui seu tamanho a medida que são adicionados
novos elementos e diminui quando são removidos.
Alocação Estática de Listas
Alocação Estática
(Listas)
Alocação Estática de Listas
Utiliza de forma sequencial a memória do computador, de tal forma que os nós

de uma lista sejam armazenados em endereços sequenciais. São, normalmente,
representadas por um vetor.
Alocação Estática de Filas
#include <stdio.h>
#include <stdlib.h>
#define MAX 3
//============================================================
int dado[MAX],qtd,op,i; //qtd = Quant. de elementos inseridos
//=============================================================
int inserir(void) //PUSH
{
if (qtd == MAX)
printf("A fila esta cheia!\n\n");
else
{
printf("Digite o valor para entrar na fila: ");
scanf("%d",&dado[qtd]);
printf("\n%d armazenado em %d\n\n",dado[qtd],qtd);
qtd++;
getchar();
}
return 0;
}
//============================================================
//============================================================
int remover(void) //POP
{
if (qtd == 0)
printf("A fila esta vazia\n\n");
else
{
qtd--;
printf("Elemento %d removido\n",dado[0]);
for (i=0;i<qtd;i++)
dado[i] = dado[i+1];
dado[i] = 0;
}
return 0;
}
//============================================================
//============================================================
int exibir(void)
{
if (qtd == 0)
printf("A fila esta vazia!\n\n");
else
for (i=0;i<qtd;i++)
printf("Posicao %d --> %d\n\n",i,dado[i]);
return 0;
}
//============================================================
int menu(void)
{
system("cls");
printf("======================\n");
printf(" FILA \n");
printf("======================\n");
printf(" 1 - Inserir \n");
printf(" 2 - Remover \n");
printf(" 3 - Exibir \n");
printf(" 4 - sair \n");
printf("======================\n");
printf("Selecione sua opcao: ");
scanf("%d",&op);
system("cls");
switch (op)
{
case 1 : inserir();
break;
case 2 : remover();
break;
case 3 : exibir();
break;
}
return 0;
}
//============================================================
int main(void)
{
while (op!=4)
{
menu();
system("pause");
}
}
//============================================================
Alocação Estática de Pilhas
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX 3
//============================================================
int dado[MAX],qtd,op,i;
//============================================================
int inserir(void) //PUSH
{
if (qtd == MAX)
printf("A pilha esta cheia!\n\n");
else
{
for (i=qtd;i>0;i--)
dado[i] = dado[i-1];
printf("Digite o valor para entrar na lista: ");
scanf("%d",&dado[0]);
printf("\n%d armazenado em %d\n\n",dado[0],0);
qtd++;
}
return 0;
}
//============================================================
//============================================================
int remover(void) //POP
{
if (qtd == 0)
printf("A pilha esta vazia\n\n");
else
{
qtd--;
printf("Elemento %d removido\n",dado[0]);
for (i=0;i<qtd;i++)
dado[i] = dado[i+1];
dado[i] = 0;
}
return 0;
}
//============================================================
//============================================================
int exibir(void)
{
if (qtd == 0)
printf("A pilha esta vazia!\n\n");
else
{
for(i=0;i<qtd-1;i++)
printf("Posicao %d --> %d\n\n",i,dado[i]);
}
return 0;
}
//============================================================
int menu(void)
{
system("cls");
printf("======================\n");
printf(" PILHA \n");
printf("======================\n");
printf(" 1 - Inserir \n");
printf(" 2 - Remover \n");
printf(" 3 - Exibir \n");
printf(" 4 - sair \n");
printf("======================\n");
printf("Selecione sua opcao: ");
scanf("%d",&op);
system("cls");
switch (op)
{
case 1 : inserir();
break;
case 2 : remover();
break;
case 3 : exibir();
break;
}
return 0;
}
//============================================================
int main(void)
{
qtd = 0;
while (op!=4)
{
menu();
system("pause");
}
return 0;
}
//============================================================
Alocação Dinâmica
(Listas)
Alocação Dinâmica de Listas
O espaço de memória é alocado em tempo de execução. Aumenta ou diminui seu

tamanho a medida que são adicionados novos elementos e diminui quando são
removidos. São implementadas com a utilização de ponteiros.
Funções
(Funções)
Funções para Alocação Dinâmica
São funções contidas na biblioteca stdlib, utilizadas no processo de alocação

dinâmica de memória. São elas:
▪ sizeof;
▪ malloc;
▪ calloc;
▪ realloc;
▪ free.
(Funções)
Função sizeof(variável ou tipo)
É uma função capaz de identificar a quantidade de bytes consumidos por uma

determinada variável.
#include <stdio.h>
#include <stdlib.h>
struct ponto
{
int x,y;
};
int main(void)
{
int v[10];
printf("short : %i\n", sizeof(short));
printf("int : %i\n", sizeof(int));
printf("float : %i\n", sizeof(float));
printf("double : %i\n", sizeof(double));
printf("int v[10] : %i\n", sizeof(v));
printf("struct ponto: %i\n", sizeof(struct ponto));
system("pause");
return 0;
}
(Funções)
Função malloc(Tamanho)
É uma função capaz de alocar espaço de memória em bytes. Recebe como

parâmetro, o tamanho em bytes a serem reservados na memória. A devolução de
malloc é do tipo void necessitando de uma conversão (CAST) antes da atribuição. O
espaço de memória alocado não é inicializado.
O nome malloc é um acrônimo de memory allocation.
(Funções)
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *p = (int *) malloc(sizeof(int));
printf("Endereco: %i\n", p);
getchar();
return 0;
}
(Funções)
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *p;
p = (int *) malloc(5 * sizeof(int));
if (p == NULL)
{
printf("Erro: Sem memoria!\n");
exit(1);
}
int i;
for (i=0; i<5; i++)
{
printf("p[%d]=%d\n",i,p[i]);
}
system("pause");
return 0;
}
(Funções)
Função calloc(Qtd, Tamanho)
É uma função capaz de alocar espaço de memória em bytes. Recebe dois

parâmetros: Qtd-Quantidade de blocos; Tamanho-Quantidade de bytes de cada
bloco de memória a ser reservado. Diferente da função malloc, inicializa as
variáveis com zero. A devolução de calloc é do tipo void necessitando de uma
conversão (CAST) antes da atribuição.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *p;
p = (int *) calloc(5, sizeof(int));
if (p == NULL)
{
printf("Erro: Sem memoria!\n");
exit(1);
}
int i;
for (i=0; i<5; i++)
{
printf("p[%d]=%d\n",i,p[i]);
}
system("pause");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *p = (int *) calloc(3,sizeof(int));
*p = 10;
*(p+1) = 20;
p[2] = 30;
printf("*p : %i\n", *p);
printf("*(p+1): %i\n", *(p+1));
printf("p[2] : %i\n", p[2]);
system("pause");
return 0;
}
(Funções)
Função realloc(variável, tamanho)
É uma função capaz de realocar espaço de memória em bytes. Recebe dois

parâmetros: variável a ser redimensionada e novo tamanho de memória em bytes.
A devolução de realloc é do tipo void necessitando de uma conversão (CAST) antes
da atribuição.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i, *vetor;
//===============================================
vetor = (int *) calloc(5, sizeof(int));
for (i=0;i<5;i++)
vetor[i]=i;
//===============================================
vetor = (int *) realloc(vetor,10 * sizeof(int));
for (i=5;i<10;i++)
vetor[i]=i;
//===============================================
for (i=0;i<10;i++)
printf("vetor[%i]=%i\n", i, vetor[i]);
system("pause");
free(vetor);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i, *vetor;
vetor = (int *) calloc(5, sizeof(int));
for (i=0;i<5;i++)
vetor[i]=i;
vetor = (int *) realloc(vetor,10 * sizeof(int));
if (vetor==NULL)
{
printf("Erro ao realocar memória!");
return(1);
}
for (i=5;i<10;i++)
vetor[i]=i;
for (i=0;i<10;i++)
printf("vetor[%i]=%i\n", i, vetor[i]);
system("pause");
free(vetor);
return 0;
}
(Funções)
Função free(variável)
É uma função capaz de desalocar espaço de memória. A função free não limpa o
valor dos espaços reservados, apenas libera para futura alocação
Lista Simplesmente Encadeada
(Lista Simplesmente Encadeada)
É aquela que possui uma sequência de elementos encadeados por ponteiros, ou seja, cada
elemento deve conter, além do dado propriamente dito, uma referência para o próximo elemento
da lista. Alguns pontos a serem destacados são:
• Tem como principal objetivo, otimizar o uso de memória;
• Permite a utilização de blocos não consecutivos de memória;
• Utiliza ponteiro como forma de encadeamento dos blocos;
• As variáveis são declaradas em tempo de execução.
HEAD
E1 E2 E3 E4 NULL
O elemento básico de uma lista encadeada é o nó. O nó é uma estrutura formada

por duas partes:
struct node
• A informação a ser armazenada; {
int num;
• Um ponteiro para o próximo nó. node *next;
};
*next
Info
Fila Simplesmente Encadeada
FELIZ SEXTA-FEIRA 13
Fila Simplesmente Encadeada
É a lista, simplesmente encadeada, que segue o princípio FIFO (First In – First

Out). Nela, o primeiro elemento a entrar será o primeiro a sair.
Criando uma Fila Simplesmente Encadeada
1-Alocar o nó cabeça;
node *HEAD = (node *) malloc(sizeof(node));

if(!HEAD)
{
printf("Sem memoria disponivel!\n");
exit(1);
}
Criando uma Fila Simplesmente Encadeada
2-Apontar o nó cabeça para NULL;
NULL
if(!HEAD)
{
exit(1);
}
HEAD->next = NULL;
Inserindo dados em uma Fila Simplesmente Encadeada
3-Alocar o novo nó;
NULL
4-Apontar o novo nó para onde o anterior está apontando;
NULL
NULL
5-Apontar o nó anterior para o novo nó;
NULL
6-Atribuir valor para o novo nó;
10 NULL
Repetir os passos de 3 a 6 para os novos nós.
10
20 NULL
Repetir os paços de 3 a 6 para os novos nós.
10
20
30 NULL
#include <stdio.h>
#include <stdlib.h>
//=============================================================
struct node
{
int num;
node *next;
};
//=============================================================
void AdicionarFim(node *HEAD) //PUSH
{
node *newnode = (node *) malloc(sizeof(node));
if(!newnode)
{
system("pause");
}
else
{
newnode->next = NULL;
if(HEAD->next == NULL)
HEAD->next=newnode;
else
{
node *tmp = HEAD->next;
while(tmp->next != NULL)
tmp = tmp->next;
tmp->next = newnode;
}
printf("newnode elemento: ");
scanf("%d", &newnode->num);
}
}
//=============================================================
void Exibir(node *HEAD)
{
if (HEAD->next == NULL)
printf("Lista vazia!");
else
{
node *tmp;
for (tmp=HEAD->next; tmp!=NULL; tmp=tmp->next)
printf("%d ", tmp->num);
}
printf("\n\n");
system("PAUSE");
}
//=============================================================
//=============================================================
void Remover(node *HEAD)
{
if (HEAD->next == NULL)
printf("Lista vazia!");
else
{
node *tmp=HEAD->next;
HEAD->next = tmp->next;
printf("No %d removido com sucesso!",tmp->num);
free(tmp);
}
printf("\n\n");
system("PAUSE");
}
//============================================================
//===============================================================
void Liberar(node *HEAD)
{
node *tmp;
while(HEAD->next != NULL)
{
tmp = (HEAD->next)->next;
free(HEAD->next);
HEAD->next = tmp;
}
}
//===============================================================
int main(void)
{
if(!HEAD)
{
exit(1);
}
HEAD->next = NULL; //Inicializa o nó
int opt;
do
{
system("CLS");
printf("==================\n");
printf(" FILA ENCADEADA \n");
printf("==================\n");
printf(" 1-Adicionar no \n");
printf(" 2-Remover no \n");
printf(" 3-Exibir fila \n");
printf(" 4-Liberar fila \n");
printf(" 5-Sair \n");
printf("==================\n");
printf("Escolha a opcao: ");
scanf("%d", &opt);
system("CLS");
switch(opt)
{
case 1: AdicionarFim(HEAD);
break;
case 2: Remover(HEAD);
break;
case 3: Exibir(HEAD);
break;
case 4: Liberar(HEAD);
Exibir(HEAD);
break;
case 5: Liberar(HEAD);
break;
default:printf("Comando invalido\n\n");
}
}while(opt!=5);
free(HEAD);
return 0;
}

Estruturas de Dados e Listas

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Estruturas de Dados e Listas

Enviado por

Direitos autorais:

Formatos disponíveis

Estrutura de Dados

O que é uma Lista?

É uma coleção de valores, ordenados ou não, armazenados de forma alinhada. As

O que é uma Fila?

É um tipo especial de lista, formada por elementos do mesmo tipo, que

O que é uma Fila?

É um tipo especial de lista, formada por elementos do mesmo tipo, que

O que é uma Pilha?

É um tipo especial de lista, formada por elementos do mesmo tipo, que

Tipos de Alocação de Memória

Alocação Estática de Listas

Utiliza de forma sequencial a memória do computador, de tal forma que os nós

Alocação Dinâmica de Listas

O espaço de memória é alocado em tempo de execução. Aumenta ou diminui seu

Funções para Alocação Dinâmica

São funções contidas na biblioteca stdlib, utilizadas no processo de alocação

Função sizeof(variável ou tipo)

É uma função capaz de identificar a quantidade de bytes consumidos por uma

É uma função capaz de alocar espaço de memória em bytes. Recebe como

O nome malloc é um acrônimo de memory allocation.

Função calloc(Qtd, Tamanho)

É uma função capaz de alocar espaço de memória em bytes. Recebe dois

Função realloc(variável, tamanho)

É uma função capaz de realocar espaço de memória em bytes. Recebe dois

Lista Simplesmente Encadeada

Lista Simplesmente Encadeada

O elemento básico de uma lista encadeada é o nó. O nó é uma estrutura formada

Fila Simplesmente Encadeada

É a lista, simplesmente encadeada, que segue o princípio FIFO (First In – First

Criando uma Fila Simplesmente Encadeada

node *HEAD = (node *) malloc(sizeof(node));

Criando uma Fila Simplesmente Encadeada

2-Apontar o nó cabeça para NULL;

Inserindo dados em uma Fila Simplesmente Encadeada

3-Alocar o novo nó;

Inserindo dados em uma Fila Simplesmente Encadeada

4-Apontar o novo nó para onde o anterior está apontando;

Inserindo dados em uma Fila Simplesmente Encadeada

5-Apontar o nó anterior para o novo nó;

Inserindo dados em uma Fila Simplesmente Encadeada

6-Atribuir valor para o novo nó;

Inserindo dados em uma Fila Simplesmente Encadeada

Repetir os passos de 3 a 6 para os novos nós.

Inserindo dados em uma Fila Simplesmente Encadeada

Repetir os paços de 3 a 6 para os novos nós.

Você também pode gostar

node HEAD = (node ) malloc(sizeof(node));