O documento descreve as listas simplesmente encadeadas em C, incluindo: 1) A estrutura básica de um nó e lista; 2) Funções para inserir no início e fim da lista; 3) Função para imprimir a lista; 4) Função para remover elementos da lista.

1. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 1/68
Listas
O objetivo dessa unidade é apresentar o conteúdo relacionado a Listas. Será feita
uma abordagem focando na linguagem C.
Introdução
Até agora temos trabalhado com estruturas de dados, das mais simples às mais complexas, que têm
tamanho fixo. Por esta razão, denominam-se estruturas de dados estáticas (o seu tamanho e localização
na memória não se alteram durante a execução).
Pois bem, agora vamos unir as estruturas estáticas juntamente com a alocação dinâmica e usar esses
poderosos conceitos para criar outro importante, o de estruturas de dados dinâmicas, ou seja, as
estruturas de dados que são alocadas, realocadas e movidas o quanto e do jeito que quisermos.
A partir daí, poderemos trabalhar com conjuntos de dados dinâmicos, com por exemplo uma coleção de
números, dados de um funcionário, dados de um produto, entre outros. O que difere esses dados dos
demais é a necessidade de manipulações que faça com que eles possam crescer, encolher, sofrer
alterações ao logo da execução de determinado programa.
A primeira estrutura dinâmica que iremos estudar são as listas.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

2. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 2/68
Listas Simplesmente Encadeadas
Uma lista encadeada é uma estrutura de dados que representa um conjunto de dados organizados em
ordem linear e dinâmica. Ela é composta por células também chamadas de nós (aqui adotaremos essa
nomenclatura), que utilizando um ponteiro apontam para o próximo elemento da lista, e seu último
elemento aponta para NULL, sinalizando que não existe um próximo elemento. Para que uma lista
encadeada exista, basta guardar seu primeiro elemento. O primeiro é ligado no segundo, que é ligado no
terceiro etc.
Numa lista encadeada, para cada novo elemento inserido na estrutura, alocamos um espaço de memória
para armazená-lo. Desta forma, o espaço total de memória gasto pela estrutura é proporcional ao
número de elementos nela armazenado. No entanto, não podemos garantir que os elementos
armazenados na lista ocuparão um espaço de memória contíguo, portanto não temos acesso direto aos
elementos da lista. Para que seja possível percorrer todos os elementos da lista, devemos explicitamente
guardar o encadeamento dos elementos, o que é feito armazenando-se, junto com a informação de cada
elemento, um ponteiro para o próximo elemento da lista
Primeiros passos para a construção de uma lista simplesmente encadeada
Para representarmos um elemento da lista simplesmente encadeada (um nó) vamos utilizar uma struct,
que chamaremos de No. Vejamos:
struct No{
int num;
struct No *prox;
};
typedef struct No No;
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

3. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 3/68
Cada nó de uma lista simplesmente encadeada irá possuir pelo menos (pode ser mais de um) um atributo
que corresponde a determinado dado a ser armazenado pela lista (int, float, char, struct..) e um ponteiro
(do tipo No) que será utilizado para armazenar o endereço de memória do próximo nó (dessa maneira
"ligamos" um nó a outro nó). Aqui utilizaremos uma lista para armazenar inteiros (int num) e o ponteiro
do tipo No que apontará para o próximo nó sera *prox.
Para o controle da lista utilizaremos uma estrutura do tipo Lista. Ela contém dois ponteiros do tipo No
(inicio e fim), que irão armazenar os endereço de memória do primeiro e do último elemento da lista
respectivamente.
Para auxiliar em algumas funções, é necessário utilizar dois ponteiros auxiliares do tipo No. Então
definimos abaixo:
/*necessitaremos também de dois ponteiros auxilares *aux e *anterior */
No *aux;
No *anterior;
/*registro do tipo Lista contento dois ponteiros do tipo nó para controlar a list
struct Lista{
struct No *inicio; /*aponta para o elemento do início da lista*/
struct No *fim; /*aponta para o elemento do fim da lista*/
};
typedef struct Lista Lista;
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

4. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 4/68
Nesse ponto definiremos também uma função cria_lista( ). Ela será utilizada para criar uma lista, ou seja,
alocará dinamicamente o espaço necessário para armazenar seus ponteiros (inicio e fim ) e irá inicializá-
los com NULL. Isso indica que a lista inicialmente está vazia.
Lista* cria_lista(){
/*alocação do ponteiro li para controlar a lista*/
Lista* li = (Lista*) malloc(sizeof(Lista));
if(li != NULL){
/*Se a lista está inicialmente vazia, inicio e fim apontam para NULL */
li->fim = NULL;
li->inicio = NULL;
}
return li;
}
Na função main, devemos definir um ponteiro do tipo Lista. Ele irá receber o endereço do espaço
alocado pela função cria_lista( ) e também servirá de parâmetro para as demais funções seguintes.
int main(){
Lista *li = cria_lista();
...blocos de chamada de função...
return 0;
}
Lista simplesmente encadeada e não ordenada
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

5. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 5/68
Como o próprio nome descreve é uma lista simplesmente encadeada em que não há qualquer tipo de
ordenação em relação aos nós pertencentes à lista. A disposição dos mesmos dependerá da ordem e
local (início ou fim da lista) em que forem inseridos.
Para este tipo de lista realizaremos 5 operações:
Inserção no início da lista;
Inserção no fim da lista;
Impressão da lista;
Remoção de elemento da lista;
Esvaziar lista;
Inserção no início da lista
Esta é a implementação da função que utilizaremos para inserir um dado no início da lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

6. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 6/68
void insere_inicio_lista(Lista *li){
/*a cada inserção alocamos dinamicamente um espaço para um novo nó*/
No *novo =(No*) malloc(sizeof(No));
/*o número a ser inserido será armazenado em novo->num*/
printf("Digite o numero a ser inserido no inicio da lista: ");
scanf("%d",&novo->num);
/*caso a lista estiver vazia o primeiro elemento a ser inserido será o prime
if(li->inicio == NULL){
/*aqui fazemos com que inicio aponte para o mesmo endereço que novo apon
li->inicio = novo;
novo->prox = NULL;
/*aqui fazemos com que fim aponte para o mesmo endereço que novo aponta*
li->fim = novo;
/*caso a lista não esteja vazia*/
}else{
/*como a inserção é no inicio, o novo nó inserido receberá no atributo p
o inicio anterior será agora o segundo elemento, portante o primeiro ele
novo->prox = li->inicio;
/*aqui fazemos com que inicio aponte para o mesmo endereço do novo nó in
li->inicio = novo;
}
printf("nNumero inserido no inicio da lista!");
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

7. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 7/68
Na prática isso aconteceria da seguinte maneira:
Inicialmente temos os ponteiros inicio e fim apontados para null:
Agora inseriremos o número 3 no início da lista.
Depois vamos inserir o número 9 no início da lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

8. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 8/68
Inserção no fim da lista
Agora trataremos de inserir dados no fim da lista. Vejamos a implementação:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

9. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 9/68
void insere_fim_lista(Lista *li){
/*a cada inserção alocamos dinamicamente um espaço para um novo nó*/
No *novo =(No*) malloc(sizeof(No));
/*o número a ser inserido será armazenado em novo->num*/
printf("Digite o numero a ser inserido no fim da lista: ");
scanf("%d",&novo->num);
/*caso a lista estiver vazia o primeiro elemento a ser inserido será o prime
if(li->inicio == NULL){
/*aqui fazemos com que inicio aponte para o mesmo endereço que novo apon
li->inicio = novo;
novo->prox = NULL;
/*aqui fazemos com que fim aponte para o mesmo endereço que novo aponta*/
li->fim = novo;
/*caso a lista não esteja vazia*/
}else{
/*como a inserção é no fim, o nó para o qual fim aponta, no atributo pro
o último elemento será agora o penúltimo, e portanto deverá apontar par
li->fim->prox = novo;
/*aqui fazemos com que fim aponte para o mesmo do novo nó inserido*/
li->fim = novo;
/*aqui fazemos com que o endereço para o qual fim aponta, no atributo pr
li->fim->prox = NULL;
}
printf("nNumero inserido no fim da lista!");
getch();
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

10. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 10/68
Complementando a lista iniciada anteriormente, vamos inserir o número 6 no final da lista:
Por fim, vamos inserir o número 2 no final da lista:
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

11. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 11/68
Impressão da lista
Para imprimir os elementos da lista (do início para o fim), utilizaremos a seguinte função:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

12. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 12/68
A saída seria: 9 3 6 2.
Remoção de elemento da lista
Para removermos um determinado elemento da lista, utilizaremos a seguinte função:
void imprime_lista(Lista *li){
/*caso a lista esteja vazia*/!!");
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endere
aux = li->inicio;
do{
/*impressão do elemento que aux aponta*/
printf(" %d ", aux->num);
//*aux aponta para o próximo elemento da lista, que será o endereço
aux = aux->prox;
/*essa operação será feita até aux ser diferente de NULL, ou seja, não h
}while(aux != NULL);
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

13. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 13/68
void remover_elemento(Lista *li){
int numero;
/*a variável achou será utilizada como um contador de números removidos*/
int achou;
/*caso a lista esteja vazia*/
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
printf("Digite o elemento a ser removido: ");
scanf("%d", &numero);
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->inicio;
/*utilizando o ponteiro ele, fazemos com ele aponte para NULL*/
anterior = NULL;
achou = 0;
do{
/*caso aux-> num seja igual ao número a ser removido*/
if(aux->num == numero){
/*incrementamos achou*/
achou = achou + 1;
/*se o elemento a ser removido for o primeiro da lista*/
if(aux == li->inicio){
/*inicio apontará para o segundo elemento da lista ou para NU
caso o elemento removido seja o único elemento da lista*/
li->inicio = aux ->prox;
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

14. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 14/68
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux aponta para o inicio da lista*/
aux = li->inicio;
/*se o elemento a ser removido for o último da lista*/
}else if (aux == li->fim){
/*o elemento anterior a fim, no atributo prox apontará para N
anterior->prox = NULL;
/*fim aponta para o elemento apontado por anterior*/
li->fim = anterior;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*como era o últmo elemento da lista, aux recebe NULL*/
aux = NULL;
/*se o elemento a ser removido não for nem o primeiro nem o últim
}else{
/*o elemento anterior ao elemento a ser removido, no atributo
para qual aux->prox apontava*/
anterior->prox = aux->prox;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux aponta para o próximo elemento da lista, aquele que era
aux = anterior -> prox;
}
/*caso aux-> num não seja igual ao número a ser
}else{
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

15. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 15/68
Com base na lista criada anteriormente, faremos algumas remoções:
anterior = aux;
aux = aux -> prox;
}
/*essa operação será feita até aux ser diferente de NULL, ou seja, não ho
}while(aux != NULL);
/*impressão do resultado*/
if(achou == 0){
printf("Numero nao encontrado!");
}else{
printf("Numero removido %d vez(es)",achou);
}
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

16. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 16/68
Primeiramente, vamos remover o número 3:
E depois removeremos o número 9.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

17. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 17/68
Esvaziar lista
Nesta última operação esvaziaremos a nossa lista, isto significa remover todos os seus nós restantes
desalocando o espaço reservado para cada um. Esta é a implementação utilizada:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

18. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 18/68
O resultado final após essa operação seria esse:
void esvaziar_lista(Lista *li){
/*caso a lista esteja vazia*/
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endere
aux = li->inicio;
do{
/*inicio apontará para o próximo elemento da lista*/
li->inicio = li->inicio->prox;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux apontará para o mesmo endereço que inicio aponta*/
aux = li->inicio;
/*essa operação será feita até aux ser diferente de NULL, ou seja, não
}while(aux != NULL);
printf("nLista Esvaziada!!");
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

19. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 19/68
Lista simplesmente encadeada e ordenada
A diferença desse tipo de lista simplesmente encadeada é que ela utiliza determinado dado armazenado
como parâmetro para a ordenação da lista. No nosso caso utilizaremos "num" para ordenar nossa lista
de maneira crescente.
Para este tipo de lista realizaremos 4 operações:
Inserção na lista;
Impressão da lista;
Remoção de elemento da lista;
Esvaziar lista;
Inserção na lista
Esta é a implementação da função que utilizaremos para inserir um dado no início da lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

20. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 20/68
void insere_lista(Lista *li){
/*a cada inserção alocamos dinamicamente um espaço para um novo nó*/
No *novo =(No*) malloc(sizeof(No));
/*o número a ser inserido será armazenado em novo->num*/
printf("nDigite o no a ser inserido na lista: ");
scanf("%d",&novo->num);
/*caso a lista estiver vazia o primeiro elemento a ser inserido será o primei
if(li->inicio == NULL){
li->inicio = novo; /*aqui fazemos com que inicio aponte para o mesmo end
li->fim = novo; /*aqui fazemos com que fim aponte para o mesmo endereço
li->fim->prox = NULL; /*aqui fazemos com que o endereço para o qual fim
/*caso a lista não esteja vazia*/
}else{
anterior = NULL; /*inicialmente anterior apontará para NULL*/
aux = li->inicio; /*aux aponta para o primeiro elemento da lista*/
/*enquanto aux apontar para um nó existente e o número inserido for maio
a variação do valor de aux fará com que o novo número possa ser inseirido
while(aux !=NULL && novo->num > aux->num){
anterior = aux; /*anterior aponta para o endereço que aux aponta*/
aux = aux->prox; /*aux aponta para o próximo nó da lista*/
}
/*caso não exista nenhum número menor que o novo número*/
if(anterior == NULL){
novo->prox = li->inicio; /*o novo elemento no atributo prox, apontar
li->inicio = novo; /*novo será o primeiro elemento da lista, inicio
/*caso não exista nenhum número maior que o novo número*/
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

21. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 21/68
Na prática isso aconteceria da seguinte maneira:
Inicialmente temos os ponteiros inicio e fim apontados para null:
}else if(aux == NULL){
li->fim->prox = novo; /*o até então ultimo elemento da lista no atri
li->fim = novo; /*novo será o ultimo elemento da lista, fim apontará
li->fim->prox = NULL; /*aqui fazemos com que o endereço para o qual f
/*caso número precise ser inseirido no meio da lista*/
}else{
anterior->prox = novo; /*o primeiro número menor que o novo inseirido
novo->prox = aux; /*novo no atibuto prox, recebe o endereço do primei
}
}
printf("nNumero inserido na lista!");
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

22. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 22/68
Primeiro: inseriremos o número 3 na lista.
Segundo: inseriremos o número 9 na lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

23. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 23/68
Terceiro: inseriremos o número 6 na lista.
Quarto: inseriremos o número 2 na lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

24. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 24/68
Impressão da lista
Para imprimir os elementos da lista (do início para o fim), utilizaremos a seguinte função:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

25. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 25/68
A saída seria: 2 3 6 9.
Remoção de elemento da lista
Para removermos um determinado elemento da lista, utilizaremos a seguinte função:
void imprime_lista(Lista *li){
/*caso a lista esteja vazia*/!!");
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endere
aux = li->inicio;
do{
/*impressão do elemento que aux aponta*/
printf(" %d ", aux->num);
//*aux aponta para o próximo elemento da lista, que será o endereço
aux = aux->prox;
/*essa operação será feita até aux ser diferente de NULL, ou seja, não h
}while(aux != NULL);
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

26. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 26/68
void remover_elemento(Lista *li){
int numero;
/*a variável achou será utilizada como um contador de números removidos*/
int achou;
/*caso a lista esteja vazia*/
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
printf("Digite o elemento a ser removido: ");
scanf("%d", &numero);
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->inicio;
/*utilizando o ponteiro ele, fazemos com ele aponte para NULL*/
anterior = NULL;
achou = 0;
do{
/*caso aux-> num seja igual ao número a ser removido*/
if(aux->num == numero){
/*incrementamos achou*/
achou = achou + 1;
/*se o elemento a ser removido for o primeiro da lista*/
if(aux == li->inicio){
/*inicio apontará para o segundo elemento da lista ou para NU
caso o elemento removido seja o único elemento da lista*/
li->inicio = aux ->prox;
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

27. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 27/68
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux aponta para o inicio da lista*/
aux = li->inicio;
/*se o elemento a ser removido for o último da lista*/
}else if (aux == li->fim){
/*o elemento anterior a fim, no atributo prox apontará para N
anterior->prox = NULL;
/*fim aponta para o elemento apontado por anterior*/
li->fim = anterior;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*como era o últmo elemento da lista, aux recebe NULL*/
aux = NULL;
/*se o elemento a ser removido não for nem o primeiro nem o últim
}else{
/*o elemento anterior ao elemento a ser removido, no atributo
para qual aux->prox apontava*/
anterior->prox = aux->prox;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux aponta para o próximo elemento da lista, aquele que era
aux = anterior -> prox;
}
/*caso aux-> num não seja igual ao número a ser
}else{
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

28. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 28/68
Com base na lista criada anteriormente, faremos algumas remoções:
anterior = aux;
aux = aux -> prox;
}
/*essa operação será feita até aux ser diferente de NULL, ou seja, não ho
}while(aux != NULL);
/*impressão do resultado*/
if(achou == 0){
printf("Numero nao encontrado!");
}else{
printf("Numero removido %d vez(es)",achou);
}
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

29. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 29/68
Vamos então remover o número 6:
Também removeremos o número 2.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

30. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 30/68
Por fim removeremos o número 9.
Esvaziar lista
Nesta última operação esvaziaremos a nossa lista, isto significa remover todos os seus nós restantes
desalocando o espaço reservado para cada um. Esta é a implementação utilizada:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

31. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 31/68
O resultado final após essa operação seria esse:
void esvaziar_lista(Lista *li){
/*caso a lista esteja vazia*/
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endere
aux = li->inicio;
do{
/*inicio apontará para o próximo elemento da lista*/
li->inicio = li->inicio->prox;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux apontará para o mesmo endereço que inicio aponta*/
aux = li->inicio;
/*essa operação será feita até aux ser diferente de NULL, ou seja, não
}while(aux != NULL);
printf("nLista Esvaziada!!");
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

32. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 32/68
Video Explicativo - Listas Simplesmente
Encadeadas
0:00 / 32:04
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

33. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 33/68
Listas Duplamente Encadeadas
Assim como as listas simplesmente encadeadas, uma lista duplamente encadeada é uma estrutura de
dados que representa um conjunto de dados organizados em ordem linear e dinâmica. Ela também é
composta por células ou nós (nomenclatura adotada), no entanto, a conexão entre os seus elementos é
feita através de dois ponteiros (um que aponta para o elemento anterior, e o outro, para o seguinte).
Numa lista duplamente encadeada, para cada novo elemento inserido na estrutura, alocamos um espaço
de memória para armazená-lo. Desta forma, o espaço total de memória gasto pela estrutura é
proporcional ao número de elementos nela armazenado. No entanto, não podemos garantir que os
elementos armazenados na lista ocuparão um espaço de memória contíguo, portanto não temos acesso
direto aos elementos da lista. Para que seja possível percorrer todos os elementos da lista, devemos
explicitamente guardar o encadeamento dos elementos, o que é feito armazenando-se, junto com a
informação de cada elemento, um ponteiro para o próximo elemento da lista e um ponteiro para o
elemento anterior.
Características a destacar:
O ponteiro anterior do primeiro elemento deve apontar para NULL (o início da lista);
O ponteiro próximo do último elemento deve apontar para NULL (o fim da lista).
Para acessar um elemento, a lista pode ser percorrida pelos dois lados.
Primeiros passos para a construção de uma lista duplamente encadeada
Para representarmos um elemento da lista (um nó) vamos utilizar uma struct, que chamaremos de No.
Vejamos:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

34. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 34/68
struct No{
int num;
struct No *prox;
struct No *ant;
};
typedef struct No No;
Cada nó de uma lista duplamente encadeada irá possuir pelo menos (pode ser mais de um) um atributo
que corresponde determinado dado a ser armazenado pela lista (int, float, char, struct..), um ponteiro (do
tipo No) *prox que será utilizado para armazenar o endereço de memória do próximo nó e outro
ponteiro (do tipo No) *ant que será utilizado para armazenar o endereço de memória do nó anterior
(dessa maneira "ligamos" duas vezes um nó a outro nó). Aqui utilizaremos uma lista para armazenar
inteiros (int num).
Para o controle da lista utilizaremos uma estrutura do tipo Lista. Ela contém dois ponteiros do tipo No
(inicio e fim), que irão armazenar os endereço de memória do primeiro e do último elemento da lista
respectivamente.
/*registro do tipo Lista contento dois ponteiros do tipo nó para controlar a list
struct Lista{
struct No *inicio; /*aponta para o elemento do início da lista*/
struct No *fim; /*aponta para o elemento do fim da lista*/
};
typedef struct Lista Lista;
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

35. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 35/68
Para auxiliar em algumas funções, é necessário utilizar três ponteiros auxiliares do tipo No. Então
definimos abaixo:
/*necessitaremos também de três ponteiros auxilares *aux , *aux2 e *anterior */
No *aux;
No *aux2;
No *anterior;
Nesse ponto definiremos também uma função cria_lista( ). Ela será utilizada para criar uma lista, ou seja,
alocará dinamicamente o espaço necessário para armazenar seus ponteiros (inicio e fim ) e irá inicializá-
los com NULL. Isso indica que a lista inicialmente está vazia.
Lista* cria_lista(){
/*alocação do ponteiro li para controlar a lista*/
Lista* li = (Lista*) malloc(sizeof(Lista));
if(li != NULL){
/*Se a lista está inicialmente vazia, inicio e fim apontam para NULL */
li->fim = NULL;
li->inicio = NULL;
}
return li;
}
Na função main, devemos definir um ponteiro do tipo Lista. Ele irá receber o endereço do espaço
alocado pela função cria_lista( ) e também servirá de parâmetro para as demais funções seguintes.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

36. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 36/68
int main(){
Lista *li = cria_lista();
...blocos de chamada de função...
return 0;
}
Lista duplamente encadeada e não ordenada
Como o próprio nome descreve é uma lista duplamente encadeada em que não há qualquer tipo de
ordenação em relação aos nós pertencentes à lista. A disposição dos mesmos dependerá da ordem e
local (início ou fim da lista) em que forem inseridos.
Para este tipo de lista realizaremos 6 operações:
Inserção no início da lista;
Inserção no fim da lista;
Impressão da lista do ínicio ao fim;
Impressão da lista do fim ao início;
Remoção de elemento da lista;
Esvaziar lista
Inserção no início da lista
Esta é a implementação da função que utilizaremos para inserir um dado no início da lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

37. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 37/68
void insere_inicio_lista(Lista *li){
/*a cada inserção alocamos dinamicamente um espaço para um novo nó*/
No *novo =(No*) malloc(sizeof(No));
/*o número a ser inserido será armazenado em novo->num*/
printf("Digite o numero a ser inserido no inicio da lista: ");
scanf("%d",&novo->num);
/*caso a lista estiver vazia o primeiro elemento a ser inserido será o primei
if(li->inicio == NULL){
li->inicio = novo; /*aqui fazemos com que inicio aponte para o mesmo ende
li->fim = novo; /*aqui fazemos com que fim aponte para o mesmo endereço q
/*como será o único elemento da lista, novo->prox e novo->ant apontam par
novo->prox = NULL;
novo->ant = NULL;
/*caso a lista não esteja vazia*/
}else{
/*como a inserção é no inicio, o novo nó inserido receberá no atributo pr
o endereço que inicio aponta*/
novo->prox = li->inicio;
/*inicio no atributo ant recebe o endereço de novo, aqui ainda inicio não
para que quando for o segundo da lista este elemento possa apontar (a
tornará o novo inicio*/
li->inicio->ant = novo;
/*novo no atributo ant recebe null, como depois se tornará o primeiro ele
nó anterior será null*/
novo->ant = NULL;
/*aqui inicio apontará para o novo nó inserido*/
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

38. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 38/68
Na prática isso aconteceria da seguinte maneira:
Inicialmente temos os ponteiros inicio e fim apontados para null:
Agora inseriremos o número 8 no início da lista.
li->inicio = novo;
}
printf("nNumero inserido na lista!");
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

39. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 39/68
Depois vamos inserir o número 9 no início da lista.
Inserção no fim da lista
Agora trataremos de inserir dados no fim da lista. Vejamos a implementação:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

40. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 40/68
void insere_fim_lista(Lista *li){
/*a cada inserção alocamos dinamicamente um espaço para um novo nó*/
No *novo =(No*) malloc(sizeof(No));
/*o número a ser inserido será armazenado em novo->num*/
printf("Digite o numero a ser inserido no fim da lista: ");
scanf("%d,&novo->num);
/*caso a lista estiver vazia o primeiro elemento a ser inserido será o primei
if( li->inicio == NULL){
li->inicio = novo; /*aqui fazemos com que inicio aponte para o mesmo ende
li->fim = novo; /*aqui fazemos com que fim aponte para o mesmo endereço q
/*como será o único elemento da lista, novo->prox e novo->ant apontam par
novo->prox = NULL;
novo->ant = NULL;
}else{
/*fim no atributo prox recebe o endereço de novo, aqui ainda fim não foi
quando esse elemento vier a ser o penultimo da lista possa apontar para o
li->fim->prox = novo;
/*como a inserção é no fim, o novo nó inserido receberá no atributo ant(s
atual endereço que fim aponta*/
novo->ant = li->fim;
/*como será o ultimo elemento da lista, novo no atributo prox apontará pa
novo->prox = NULL;
/*fim aponta para o novo nó inserido*/
li->fim = novo;
}
printf("nNumero inserido na lista!");
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

41. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 41/68
Complementando a lista iniciada anteriormente, vamos inserir o número 3 no final da lista:
Por fim, vamos inserir o número 5 no final da lista:
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

42. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 42/68
Impressão da lista do início ao fim
Para imprimir os elementos da lista (do início para o fim), utilizaremos a seguinte função:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

43. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 43/68
A saída seria: 9 8 3 5.
Impressão da lista do fim ao início
Para imprimir os elementos da lista (do fim para o início), utilizaremos a seguinte função:
void imprime_lista_inicio_ao_fim(Lista *li){
/*caso a lista esteja vazia*/
if( li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->inicio;
do{
/*impressão do elemento que aux aponta*/
printf(" %d ", aux->num);
/*aux aponta para o próximo elemento da lista, que será o endereço co
aux = aux->prox;
/*essa operação será feita até aux ser diferente de NULL, ou seja, nã
a serem impressos*/
}while(aux != NULL);
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

44. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 44/68
A saída seria: 5 3 8 9.
Remoção de elemento da lista
Para removermos um determinado elemento da lista, utilizaremos a seguinte função:
void imprime_lista_fim_ao_inicio(Lista *li){
/*caso a lista esteja vazia*/
if( li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->fim;
do{
/*impressão do elemento que aux aponta*/
printf(" %d ", aux->num);
/*aux aponta para o elemento anterior da lista, que será o endereço c
aux = aux->ant;
/*essa operação será feita até aux ser diferente de NULL, ou seja, nã
a serem impressos*/
}while(aux != NULL);
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

45. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 45/68
void remover_elemento(Lista *li){
int numero, achou; /*a variável achou será utilizada como um contador de núme
if(li->inicio == NULL){ /*caso a lista esteja vazia*/
printf("nLista Vazia!!");
}else{ /*caso a lista não esteja vazia*/
printf("Digite o elemento a ser removido: ");
scanf("%d", &numero);
aux = li->inicio; /*utilizando o ponteiro aux, fazemos com ele aponte p
achou = 0;
do{
if(aux->num == numero){ /*caso aux-> num seja igual ao número a ser r
achou = achou + 1; /*incrementamos achou*/
if(aux == li->inicio){ /*se o elemento a ser removido for o prim
li->inicio = aux ->prox; /*inicio apontará para o segundo ele
removido seja o único
if( li->inicio != NULL){ /*caso inicio tenha não recebido nul
li->inicio->ant = NULL; /*ant de inicio também apontará
}
free(aux); /*desalocamos o espaço para onde aux apontava*/
aux = li->inicio; /*aux aponta para o inicio da lista*/
}else if(aux == li->fim){ /*se o elemento a ser removido for o ul
li->fim = li->fim->ant; /*fim apontará para o el
li->fim->prox = NULL; /*fim no atributo prox apon
free(aux); /*desalocamos o espaço para onde aux a
aux = NULL; /*como era o últmo elemento da lista,
}else{ /*se o elemento a ser removido não for nem o prime
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

46. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 46/68
aux->ant->prox = aux->prox; /*o elemento anterior
aux->prox->ant = aux->ant; /*o elemento seguinte
aux2 = aux->prox; /*aux2 aponta para o elemento d
free(aux); /*desalocamos o espaço para onde aux a
aux = aux2; /*aux aponta para onde aux2 apontava*
}
}else{ /*caso aux-> num não seja igual ao número a ser removido*/
aux = aux -> prox; /*aux aponta para o próximo elemento da li
}
/*essa operação será feita até aux ser diferente de NULL, ou seja, não ho
}while(aux != NULL);
/*impressão do resultado*/
if(achou == 0){
printf("Numero nao encontrado!");
}else{
printf("Numero removido %d vez(es)",achou);
}
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

47. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 47/68
Com base na lista criada anteriormente, faremos algumas remoções:
Primeiramente, vamos remover o número 9:
Vamos então remover o número 3:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

48. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 48/68
Por fim removeremos o número 8.
Esvaziar lista
Nesta última operação esvaziaremos a nossa lista, isto significa remover todos os seus nós restantes
desalocando o espaço reservado para cada um. Esta é a implementação utilizada:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

49. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 49/68
O resultado final após essa operação seria esse:
void esvaziar_lista(Lista *li){
/*caso a lista esteja vazia*/
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->inicio;
do{
/*inicio apontará para o próximo elemento da lista*/
li->inicio = li->inicio->prox;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux apontará para o mesmo endereço que inicio aponta*/
aux = li->inicio;
/*essa operação será feita até aux ser diferente de NULL, ou seja, não ho
}while(aux != NULL);
printf("nLista Esvaziada!!");
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

50. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 50/68
Lista duplamente encadeada e ordenada
A diferença desse tipo de lista duplamente encadeada é que ela utiliza determinado dado armazenado
como parâmetro para a ordenação da lista. No nosso caso utilizaremos "num" para ordenar nossa lista
de maneira crescente.
Para este tipo de lista realizaremos 5 operações:
Inserção na lista;
Impressão da lista do ínicio ao fim;
Impressão da lista do fim ao início;
Remoção de elemento da lista;
Esvaziar lista
Inserção na lista
Esta é a implementação da função que utilizaremos para inserir um dado na lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

51. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 51/68
void insere_lista(Lista *li){
No *novo =(No*) malloc(sizeof(No)); /*a cada inserção alocamos dinamicamente
/*o número a ser inserido será armazenado em novo->num*/
printf("Digite o numero a ser inserido na lista: ");
scanf("%d",&novo->num);
if(li->inicio == NULL){ /*caso a lista estiver vazia o elemento a ser inserid
/*como será o único elemento da lista, novo->prox e novo->ant apontam par
novo->prox = NULL;
novo->ant = NULL;
li->inicio = novo; /*aqui fazemos com que inicio aponte para o mesmo ende
li->fim = novo; /*aqui fazemos com que fim aponte para o mesmo endereço q
}else{ /*caso a lista não esteja vazia*/
aux = li->inicio; /*aux aponta para o endereço que inicio aponta*/
/*enquanto ainda houverem elementos na lista e o novo número for maior qu
ou seja enquanto não for encontrado um número maior que o número inserid
while(aux != NULL && novo->num > aux->num){
aux = aux->prox; /*aux aponta para o próximo elemento da lista*/
/*isso é feito para encontrar o ponto exato para o número ser inseri
}
/*caso não existam números maiores ou iguais ao novo número , ele será in
if(aux == li->inicio){
novo->prox = li->inicio; /*novo->prox apontara para o atual inicio, q
novo->ant = NULL; /*como novo será o primeiro da lista, seu ponteiro
li->inicio->ant = novo; /*o inicio atual(que depois será o segunda da
li->inicio = novo; /*inicio aponta para novo*/
/*caso todos elementos da lista sejam menores que o número a ser inserido
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

52. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 52/68
Na prática isso aconteceria da seguinte maneira:
Inicialmente temos os ponteiros inicio e fim apontados para null:
}else if(aux == NULL){
li->fim->prox = novo; /*o fim atual (que depois será o penultimo da l
novo->ant = li->fim; /*novo -> ant aponta para o endereço do fim atua
li->fim = novo; /*fim aponta para novo*/
li->fim->prox = NULL; /*todo ultimo elemento da lista em prox aponta
}else{ /*caso novo seja inserido no meio da lista, ele será inserido ant
novo->prox = aux; /*novo será inserido antes do aux atual, então novo
aux->ant->prox = novo; /*o número que estava antes de aux em prox apo
novo->ant = aux->ant; /*novo-> ant aponta para o nó anterior a aux at
aux->ant = novo; /*aux atual será o elemento seguinte a novo, portant
}
}
printf("nNumero inserido na lista!");
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

53. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 53/68
Primeiro: inseriremos o número 5 na lista.
Segundo: vamos inserir o número 9 na lista.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

54. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 54/68
Terceiro: vamos inserir o número 2 na lista:
Por fim, vamos inserir o número 7 na lista:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

55. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 55/68
Impressão da lista do início ao fim
Para imprimir os elementos da lista (do início para o fim), utilizaremos a seguinte função:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

56. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 56/68
A saída seria: 2 5 7 9.
Impressão da lista do fim ao início
Para imprimir os elementos da lista (do fim para o início), utilizaremos a seguinte função:
void imprime_lista_inicio_ao_fim(Lista *li){
/*caso a lista esteja vazia*/
if( li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->inicio;
do{
/*impressão do elemento que aux aponta*/
printf(" %d ", aux->num);
/*aux aponta para o próximo elemento da lista, que será o endereço co
aux = aux->prox;
/*essa operação será feita até aux ser diferente de NULL, ou seja, nã
a serem impressos*/
}while(aux != NULL);
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

57. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 57/68
A saída seria: 9 7 5 2.
Remoção de elemento da lista
Para removermos um determinado elemento da lista, utilizaremos a seguinte função:
void imprime_lista_fim_ao_inicio(Lista *li){
/*caso a lista esteja vazia*/
if( li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->fim;
do{
/*impressão do elemento que aux aponta*/
printf(" %d ", aux->num);
/*aux aponta para o elemento anterior da lista, que será o endereço c
aux = aux->ant;
/*essa operação será feita até aux ser diferente de NULL, ou seja, nã
a serem impressos*/
}while(aux != NULL);
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

58. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 58/68
void remover_elemento(Lista *li){
int numero, achou; /*a variável achou será utilizada como um contador de núme
if(li->inicio == NULL){ /*caso a lista esteja vazia*/
printf("nLista Vazia!!");
}else{ /*caso a lista não esteja vazia*/
printf("Digite o elemento a ser removido: ");
scanf("%d", &numero);
aux = li->inicio; /*utilizando o ponteiro aux, fazemos com ele aponte p
achou = 0;
do{
if(aux->num == numero){ /*caso aux-> num seja igual ao número a ser r
achou = achou + 1; /*incrementamos achou*/
if(aux == li->inicio){ /*se o elemento a ser removido for o prim
li->inicio = aux ->prox; /*inicio apontará para o segundo ele
removido seja o único
if( li->inicio != NULL){ /*caso inicio tenha não recebido nul
li->inicio->ant = NULL; /*ant de inicio também apontará
}
free(aux); /*desalocamos o espaço para onde aux apontava*/
aux = li->inicio; /*aux aponta para o inicio da lista*/
}else if(aux == li->fim){ /*se o elemento a ser removido for o ul
li->fim = li->fim->ant; /*fim apontará para o el
li->fim->prox = NULL; /*fim no atributo prox apon
free(aux); /*desalocamos o espaço para onde aux a
aux = NULL; /*como era o últmo elemento da lista,
}else{ /*se o elemento a ser removido não for nem o prime
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

59. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 59/68
aux->ant->prox = aux->prox; /*o elemento anterior
aux->prox->ant = aux->ant; /*o elemento seguinte
aux2 = aux->prox; /*aux2 aponta para o elemento d
free(aux); /*desalocamos o espaço para onde aux a
aux = aux2; /*aux aponta para onde aux2 apontava*
}
}else{ /*caso aux-> num não seja igual ao número a ser removido*/
aux = aux -> prox; /*aux aponta para o próximo elemento da li
}
/*essa operação será feita até aux ser diferente de NULL, ou seja, não ho
}while(aux != NULL);
/*impressão do resultado*/
if(achou == 0){
printf("Numero nao encontrado!");
}else{
printf("Numero removido %d vez(es)",achou);
}
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

60. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 60/68
Com base na lista criada anteriormente, faremos algumas remoções:
Primeiramente, vamos remover o número 5 da nossa lista:
Depois removeremos o número 9.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

61. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 61/68
E por fim removeremos o número 2.
Esvaziar lista
Nesta última operação esvaziaremos a nossa lista, isto significa remover todos os seus nós restantes
desalocando o espaço reservado para cada um. Esta é a implementação utilizada:
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

62. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 62/68
O resultado final após essa operação seria esse:
void esvaziar_lista(Lista *li){
/*caso a lista esteja vazia*/
if(li->inicio == NULL){
printf("nLista Vazia!!");
/*caso a lista não esteja vazia*/
}else{
/*utilizando o ponteiro aux, fazemos com ele aponte para o mesmo endereç
aux = li->inicio;
do{
/*inicio apontará para o próximo elemento da lista*/
li->inicio = li->inicio->prox;
/*desalocamos o espaço para onde aux apontava*/
free(aux);
/*aux apontará para o mesmo endereço que inicio aponta*/
aux = li->inicio;
/*essa operação será feita até aux ser diferente de NULL, ou seja, não ho
}while(aux != NULL);
printf("nLista Esvaziada!!");
}
getch();
}
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

63. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 63/68
Video Explicativo - Listas Duplamente Encadeadas
Listas Circulares
0:00 / 34:08
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

64. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 64/68
As listas citadas anteriormente também podem ser implementadas de forma circular. Isso significa que,
quando forem simplesmente encadeadas seu ponteiro próximo “*prox” do último elemento apontará
para o primeiro elemento da lista. Já quando forem duplamente encadeadas terão além do ponteiro
próximo “*prox” do último elemento apontando para o primeiro elemento da lista, o ponteiro anterior
“*ant” do primeiro elemento apontará para o último elemento da lista.
Lista circular simplesmente encadeada e não ordenada
Lista circular simplesmente encadeada e ordenada
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

65. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 65/68
Lista circular duplamente encadeada e não ordenada.
Lista circular duplamente encadeada e ordenada.
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

66. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 66/68
Exercícios
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

67. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 67/68
REA-AED
Desenvolvido por Gabriel Bueno da Silva
Contato: gabrielbuenodasilva@yahoo.com.br
Utilização do tema:
Flatfy Theme (http://www.andreagalanti.it/flatfy) by
Andrea Galanti
(http://www.andreagalanti.it)
is licensed to the public under
the Creative
Commons Attribution 3.0 License - NOT COMMERCIAL
(http://creativecommons.org/licenses/by-nc/3.0/it/deed.it).
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)

68. 11/10/21, 12:50 Aula - Listas
https://gabrielbueno072.github.io/rea-aed/aula_list.html 68/68
REA-AED Home (index.html) Aulas Bibliografia (biblio.html)