30/06/2017 Lista duplamente encadeada

Lista duplamente encadeada

1. Requisitos
2. INTRODUO
3. Definio
4. A construo do prottipo de um
elemento da lista
5. Operaes em listas duplamente
encadeadas
1. Inicializao
2. Insero de um elemento na
lista
1. Insero em uma lista
vazia
2. Insero no incio da lista
3. Insero no fim da lista
4. Insero antes de um
elemento da lista
5. Insero depois de um
elemento da lista
3. Remoo de um elemento da
lista
1. Remoo na lista
4. Exibio da lista
5. Destruio da lista
6. Exemplo completo
1. dlista.h
2. dlista_function.h
3. dlista.c
7. Veja tambm
8. Veja tambm: Retirada de lista
duplamente encadeada em c

Requisitos
Os tipos de dados As estruturas O uso do typedef Os ponteiros As funes do usurio As listas simplesmente encadeadas
(facultativo)

INTRODUO
Este artigo mostrar como fazer as listas duplamente ligadas. A escolha da implementao ser dependente das suas
necessidades e seu desempenho. As listas duplamente encadeadas podem ser usadas quando vrias operaes de
http://br.ccm.net/faq/10254-lista-duplamente-encadeada 1/16
30/06/2017 Lista duplamente encadeada

insero/remoo de elementos so necessrias.

Definio
As listas duplamente encadeadas so estruturas de dados semelhantes s listas simplesmente encadeadas. A alocao da
memria feita durante a execuo. No entanto, em comparao com as listas simplesmente encadeadas a conexo entre os
elementos feita atravs de dois ponteiros (um que aponta para o elemento anterior, e o outro, para o seguinte). O ponteiro
anterior ao primeiro elemento deve apontar para NULL (o incio da lista). O ponteiro seguinte ao ltimo elemento deve
apontar para NULL (o fim da lista). Para acessar um elemento, a lista pode ser percorrida pelos dois lados: Partindo do alto,
o ponteiro seguinte permite o deslocamento para o elemento seguinte e comeando do final, o ponteiro anterior permite o
deslocamento para o elemento anterior. Em suma, o movimento feito em ambas as direes, do primeiro para o ltimo
elemento e/ou do ltimo para o primeiro.

A construo do prottipo de um elemento da lista

Estabelea um elemento da lista com o tipo struct. O elemento da lista ter um campo dado, um ponteiro anterior e um
ponteiro seguinte. Os ponteiros anterior e seguinte devem ser do mesmo tipo que o elemento, se no, eles no podero se
dirigir para um elemento da lista. O ponteiro do anterior permitir o acesso ao elemento anterior, enquanto que o ponteiro
seguinte vai permitir o acesso ao prximo elemento.

typedef struct dl_elementoLista { char *dado; struct dl_elementoLista *anterior; struct

dl_elementoLista *seguinte; }dl_elemento;

Para o controle da lista, o melhor salvar certos elementos: o primeiro elemento, o ltimo elemento e o nmero de
elementos. Para tanto, usaremos outra estrutura (isto no obrigatrio, as variveis podem ser usadas). Veja a sua
composio:

typedef struct dl_ListaDetectada { dl_elemento *incio; dl_elemento *fim; int tamanho;

}dl_Lista;

O ponteiro inicial ter o endereo do primeiro elemento da lista. O ponteiro fim abrigar o endereo do ltimo elemento da
lista. A varivel tamanho contm o nmero de elementos. Qualquer que seja a posio na lista, os ponteiros de incio e fim
vo indicar, respectivamente, para o primeiro e o ltimo elemento. O tamanho ter o nmero de elementos da lista, seja
qual for a operao efetuada na lista.

Operaes em listas duplamente encadeadas

Basta uma nica funo aara a insero e a excluso, se ela foi bem desenvolvida, de acordo com as necessidades. No
entanto, lembrem-se que este artigo puramente didtico. por essa razo que eu escrevi uma funo para cada operao
de insero e excluso.

Inicializao

Prottipo da funo: void inicializao (Lista *lista); que dever ser feita antes de qualquer outra operao da lista.
A funo inicia o ponteiro de incio e de fim, sempre atravs do ponteiro NULL e do tamanho com o valor 0. A funo

void inicializao (Lista *lista){ lista>incio = NULL; lista>fim = NULL; tamanho = 0; }

Insero de um elemento na lista

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 2/16
30/06/2017 Lista duplamente encadeada

Veja o algoritmo de insero e de backup dos elementos: Declarao dos elementos a serem inseridos Alocao da memria
para o novo elemento Preenchimento do contedo do campo de dados Atualizao dos ponteiros para o elemento anterior e
o elemento seguinte A atualizao dos ponteiros com vistas do primeiro e do ltimo elemento, se necessrio. Caso
particular: em uma lista com apenas um elemento, o primeiro tambm o ltimo. Atualizao do Tamanho lista. Para
adicionar um elemento na lista, existem vrias solues: 1. Insero em uma lista vazia 2. Insero no incio da lista 3.
Insero no fim da lista 4. Insero antes de um elemento 5. Insero depois de um elemento

Insero em uma lista vazia

Prottipo da funo: int ins_na_lista_vazia (dl_Lista * lista, char *dado); A funo volta para -1, no caso de
uma falha, caso contrrio ela retorna 0. Passos: Alocao da memria para o novo elemento Preenchimento do campo de
dados do novo elemento O ponteiro anterior do novo elemento indicar o NULL O ponteiro seguinte do novo elemento
dirigir para NULL Os ponteiros de incio e de fim indicaro para o novo elemento O tamanho atualizado. A funo

int insero_na_lista_vazia (dl_Lista * lista, char *dado){ dl_elemento *novo_elemento; if

((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy (novo_elemento>dado, dado);
novo_elemento>anterior = lista>incio; novo_elemento>seguinte = lista>fim; lista>incio =
novo_elemento; lista>fim = novo_elemento; liste>tamanho++; return 0; }

Insero no incio da lista

Prottipo da funo: int ins_incio_lista (dl_Lista * lista, char *dado); Volta a funo -1 com falha, ela retorna
0. Passos: Alocao da memria para o novo elemento Preenchimento do campo de dados do novo elemento O ponteiro
anterior ao novo elemento aponta para NULL O ponteiro seguinte aponta para o 1 elemento O ponteiro anterior ao 1
elemento indica o novo elemento O ponteiro de incio direciona para o novo elemento O ponteiro de fim no muda O
tamanho incrementado

|300px|] A funo

int ins_incio_lista (dl_Lista * lista, char *dado){ dl_elemento *novo_elemento; if

((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy (novo_elemento>dado, dado);
novo_elemento>anterior = NULL; novo_elemento>seguinte = lista>incio; lista>incio>anterior =
novo_elemento; lista>incio = novo_elemento; lista>tamanho++; return 0; }

Insero no fim da lista

Prottipo da funo: int ins_fim_lista (dl_Lista * lista, char *dado); A funo volta para -1 no caso de falha, do
contrrio ela retorna 0. Passos: Alocao da memria para o novo elemento Preenchimento do campo de dados do novo
elemento O ponteiro seguinte ao novo elemento aponta para NULL O ponteiro anterior ao novo elemento aponta para o
ltimo elemento ( o ponteiro de fim que contm, por enquanto, o seu endereo) O ponteiro seguinte em relao ao ltimo
elemento indicar o novo elemento O ponteiro de fim aponta para o novo elemento O ponteiro de incio no muda O
tamanho incrementado [Image: http://www.commentcamarche.net/faq/images/0-GkOJj4j7-dl-ins-fim-s-.png|500px|] A
funo

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 3/16
30/06/2017 Lista duplamente encadeada

int ins_fim_lista (dl_Lista * lista, char *dado){ dl_elemento *novo_elemento; if ((novo_elemento

= aloc (novo_elemento)) == NULL) return -1; strcpy (novo_elemento>dado, dado);
novo_elemento>seguinte = NULL; novo_elemento>anterior = lista>fim; lista>fim>seguinte =
novo_elemento; lista>fim = novo_elemento; lista>tamanho++; return 0; }

Insero antes de um elemento da lista

Prottipo da funo:

int ins_antes (dl_Lista * lista, char *dado, int pos);

A funo aparece novamente -1 se tiver falha, se no for assim ela volta para o 0. A insero ser feita antes de uma certa
posio transformada em argumento para a funo. A posio indicada no deve ser nem o 1 nem o ltimo elemento. Neste
caso, preciso utilizar as funes de insero no incio e/ou fim da lista. Passos: Alocao da memria para o novo
elemento Preenchimento do campo de dados do novo elemento Faa a escolha de uma posio dentro da lista (a insero
ser feita depois da posio escolhida) O ponteiro seguinte ao novo elemento aponta para o elemento em andamento. O
ponteiro anterior ao novo elemento aponta para o endereo no qual aponta o ponteiro anterior do elemento em andamento.
(umaexplicao meio enrolada, esperando que a imagem os ajude a compreender melhor) O ponteiro seguinte ao elemento
que precede o elemento em andamento apontar para o novo elemento O ponteiro anterior ao elemento em andamento ponta
para o novo elemento O ponteiro de fim no muda O ponteiro de incio s muda se a posio escolhida for a posio 1 O
tamanho incrementado de uma unidade

|341px|]

|447px|] A funo

int ins_antes (dl_Lista * lista, char *dado, int pos){ int i; dl_elemento *novo_elemento, *em
andamento; if ((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy
(novo_elemento>dado, dado); em andamento = lista>incio; for (i = 1; i < pos; ++i) em
andamento = em andamento>seguinte; novo_elemento>seguinte = em andamento; novo_elemento> anterior
= em andamento>anterior; if(em andamento>anterior == NULL) lista>incio = novo_elemento;
else em andamento>anterior>seguinte = novo_elemento; em andamento>anterior = novo_elemento;
lista>tamanho++; return 0; }

Insero depois de um elemento da lista

Prottipo da funo:

int ins_apres (dl_Lista * lista, char *dado, int pos);

Com isso volta -1 no caso de falha, se no for assim ela retorna 0. A insero ser feita aps uma determinada posio
transformada em argumento da funo. A posio indicada no deve ser o ltimo elemento. Neste caso, utilize a funo de
insero no final da lista. Passos: Alocao da memria para o novo elemento Preenchimento do campo de dados do novo
elemento Uma posio na lista deve ser selecionada (a insero ser feita depois da posio escolhida) O ponteiro seguinte
do elemento novo vai apontar para o endereo que aponta o ponteiro seguinte do elemento em andamento (veja a imagem).
O ponteiro anterior ao novo elemento aponta para o elemento em andamento. O ponteiro anterior ao elemento que sucede o
elemento em andamento apontar para o novo elemento O ponteiro seguinte ao elemento em andamento aponta para o novo
elemento O ponteiro de incio no muda O ponteiros de fim s muda se apenas a posio escolhida for a posio do ltimo
elemento (o tamanho da lista) O tamanho incrementado de uma unidade

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 4/16
30/06/2017 Lista duplamente encadeada

A funo

int ins_apres (dl_Lista * lista, char *dado, int pos){ int i; dl_elemento *novo_elemento, *em
andamento; if ((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy
(novo_elemento>dado, dado); em andamento = lista>incio; for (i = 1; i < pos; ++i) em
andamento = em andamento>seguinte; novo_elemento>seguinte = em andamento>seguinte;
novo_elemento>anterior = em andamento; if(em andamento > seguinte == NULL) lista>fim =
novo_elemento; else em andamento >seguinte>anterior = novo_elemento; em andamento >seguinte
= novo_elemento; lista>tamanho++; return 0; }

Remoo de um elemento da lista

Veja o algoritmo de remoo de um elemento da lista: Autilizao de um ponteiro temporrio para salvar o endereo dos
elementos a serem removidos O elemento a ser removido pode estar em qualquer posio da lista. Em comparao com a
lista simplesmente encadeada, onde a remoo s pode ser feita depois de um elemento designado, as listas duplamente
encadeadas so mais fceis de manipular, graas aos dois ponteiros que mantm um rastro de antes como do depois. Liberar
a memria ocupada pelo elemento removido Atualizar o tamanho da lista Para remover um elemento da lista existem vrias
solues: 1. Remoo no incio da lista 2. Remoo no fim da lista 3. Remoo antes de um elemento 4. Remoo depois de
um elemento 5. Remoo de um elemento Porm, a remoo no incio e no fim das listas duplamente encadeadas, assim
como antes ou depois de um elemento vem a ser a remoo da posio 0 (zero) ou da posio N (N = nmero de elementos
da lista) ou em outro lugar da lista. No caso das listas duplamente encadeadas, no tem problema remover em qualquer
posio , devido aos ponteiros "anterior" e "seguinte", que mantm a ligao entre os elementos da lista. por isso que
vamos criar uma nica funo. Se quisermos remover o elemento do incio da lista, vamos escolher a posio zero Se
quisermos remover o elemento do fim da lista, vamos escolher a posio N (o nmero de elementos) Se quisermos remover
um elemento qualquer, ento vamos escolher a sua posio na lista

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 5/16
30/06/2017 Lista duplamente encadeada

Remoo na lista

Prottipo da funo:

int remov(dl_Lista *lista, int pos);

Esta funo volta a se exibir -1 em caso de falha, ou ela retorna 0. Podemos distinguir vrias situaes: Remoo da posio
1 em uma lista com apenas um elemento Remoo da posio 1 em uma lista com vrios elementos Remoo da ltima
posio (o ltimo elemento) Remoo em outro lugar da lista para uma certa posio A remoo em uma lista vazia no
tem sentido Passos: A posio escolhida 1 (o caso da remoo do 1 elemento da lista) O ponteiro remove elemento
conter o endereo do 1 elemento e o ponteiro de incio integrar o endereo mantido pelo ponteiro seguinte ao 1
elemento que queremos remover (se este ponteiro equivale a NULL ento atualizaremos o ponteiro de fim j que o caso
de uma lista com apenas um elemento, se no, apontaramos o ponteiro "anterior" ao 2 elemento para NULL) A posio
escolhida igual, com o nmero de elementos da lista e o ponteiro remov elemento conter o endereo do ltimo elemento.
Ns apontaremos o ponteiro seguinte ao antepenltimo elemento ( o elemento para o qual aponta o ponteiro anterior ao
ltimo elemento), para NULL Ns atualizaremos o ponteiro de fim. A posio escolhida aleatria na lista. O ponteiro
remov_elemento conter o endereo do elemento a ser removido e o ponteiro seguinte ao elemento que precede o elemento
a ser removido aponta para o endereo mantido pelo ponteiro seguinte ao elemento a ser removido. O ponteiro anterior ao
elemento que sucede o elemento a ser removido aponta para o endereo mantido pelo ponteiro anterior ao elemento a ser
removido e o tamanho da lista ser decrementado de um elemento: A funo

int remov(dl_Lista *lista, int pos){ int i; dl_elemento *remov_elemento,*em andamento;

if(lista>tamanho == 0) return -1; if(pos == 1){ /* remoo do 1 elemento */
remov_elemento = lista>incio; lista>incio = lista>incio>seguinte; if(lista>incio == NULL)
lista>fim = NULL; else lista>incio>anterior == NULL; }else if(pos == lista>tamanho){
/* remoo do ltimo elemento */ remov_elemento = lista>fim; lista>fim>anterior>seguinte =
NULL; lista>fim = lista>fim>anterior; }else { /* remoo em outro lugar */ em andamento =
lista>incio; for(i=1;i<pos;++i) em andamento = em andamento>seguinte;
remov_elemento = em andamento; em andamento>anterior>seguinte = em andamento>seguinte; em
andamento>seguinte>anterior = em andamento>anterior; } free(remov_elemento>dado);
free(remov_elemento); lista>tamanho--; return 0; }

Exibio da lista

Ns podemos, exibindo a lista inteira, nos posicionar no incio ou no fim da lista (o ponteiro de incio ou de fim o
permitir). Depois, utilizando o ponteiro seguinte ou anterior de cada elemento, a lista vai ser varrida do 1 ao ltimo
elemento ou do ltimo ao 1 elemento. o ponteiro seguinte do ltimo elemento que d a condio de parada e que
equivale ao NULL no caso da leitura do incio para o fim da lista, ou pelo ponteiro anterior do 1 elemento que equivale ao
NULL, no caso de uma leitura do fim para o incio da lista. As funes

void exibe(dl_Lista *lista){ /* mostrar avanando */ dl_elemento *em andamento; em andamento =

lista>incio; /* ponto de partida do 1 elemento */ printf("[ "); while(em andamento != NULL){
printf("%s ",em andamento>dado); em andamento = em andamento>seguinte; } printf("]\n"); }
void exibe_inv(dl_Lista *lista){ /* mostrar recuando */ dl_elemento *em andamento; em andamento =
lista>fim; /* ponto de partida do ltimo elemento */ printf("[ "); while(em andamento != NULL){
printf("%s : ",em andamento>dado); em andamento = em andamento>anterior; } printf("]\n");
}

Destruio da lista

Para destruir a lista inteira, utilizarei a remoo da posio 1 enquanto o tamanho for maior que zero. A funo

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 6/16
30/06/2017 Lista duplamente encadeada

void destruir(dl_Lista *lista){ while(lista>tamanho > 0) remov(liste,1); }

Exemplo completo
dlista.h

/* ---------- dlista.h ----------- */ typedef struct dl_elementoLista{ char *dado; struct

dl_elementoLista *anterior; struct dl_elementoLista*seguinte; } dl_elemento; typedef struct
dl_ListaDetectada{ dl_elemento *incio; dl_elemento *fim; int tamanho; } dl_Lista; /*
inicializao da lista */ void inicializao (dl_Lista * lista); dl_elemento *aloc (dl_elemento *
novo_elemento); /* INSERO */ int ins_em_uma_lista_vazia (dl_Lista * lista, char *dado); int
ins_incio_lista (dl_Lista * lista, char *dado); int ins_fim_lista (dl_Lista * lista, char *dado);
int ins_depois (dl_Lista * lista, char *dado, int pos); int ins_antes (dl_Lista * lista, char *dado,
int pos); /* REMOO */ int REMOV(dl_Lista *lista, int pos); void exibe (dl_Lista * lista);
/**************************/ void exibe_inv (dl_Lista * lista); void destruir (dl_Lista * lista);
/* -------- FIM lista.h --------- */

dlista_function.h

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 7/16
30/06/2017 Lista duplamente encadeada

/***************************\

dlista_function.h * \***************************/ void inicializao (dl_Lista * lista){

lista>incio = NULL; lista>fim = NULL; lista>tamanho = 0; } int
insero_em_uma_lista_vazia (dl_Lista * lista, char *dado){ dl_elemento *novo_elemento; if
((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy (novo_elemento>dado,
dado); novo_elemento>anterior = NULL; novo_elemento>seguinte = NULL; lista>incio =
novo_elemento; lista>fim = novo_elemento; lista>tamanho++; return 0; } int
ins_incio_lista (dl_Lista * lista, char *dado){ dl_elemento *novo_elemento; if
((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy (novo_elemento >dado,
dado); novo_elemento >anterior = NULL; novo_elemento >seguinte = liste>incio;
lista>incio >anterior = novo_elemento; lista>incio = novo_elemento; lista>tamanho++;
return 0; } int ins_fim_lista (dl_Lista * lista, char *dado){ dl_elemento *novo_elemento;
if ((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy (novo_elemento>dado,
dado); novo_elemento >seguinte = NULL; novo_elemento >anterior = lista>fim;
lista>fim>seguinte = novo_elemento; lista>fim = novo_elemento; lista>tamanho++; return 0;
} int ins_depois (dl_Lista * lista, char *dado, int pos){ int i; dl_elemento *novo_elemento,
*em andamento; if ((novo_elemento = aloc (novo_elemento)) == NULL) return -1; strcpy
(novo_elemento>dado, dado); em andamento = lista>incio; for (i = 1; i < pos; ++i) em
andamento = em andamento>seguinte; novo_elemento>seguinte = em andamento>seguinte;
novo_elemento>anterior = em andamento; if(em andamento>seguinte == NULL) lista>fim =
novo_elemento; else em andamento >seguinte >anterior = novo_elemento; em andamento
>seguinte = novo_elemento; lista>tamanho++; return 0; } int ins_antes (dl_Lista * lista,
char *dado, int pos){ int i; dl_elemento *novo_elemento, *em andamento; if ((novo_elemento
= aloc (novo elemento)) == NULL) return -1; strcpy (novo_elemento>dado, dado); em
andamento = lista>incio; for (i = 1; i < pos; ++i) em andamento = em andamento>seguinte;
novo_elemento >seguinte = em andamento; novo_elemento > anterior = em andamento>anterior;
if(em andamento >anterior == NULL) lista>incio = novo_elemento; else em
andamento>anterior>seguinte = novo_elemento; em andamento>anterior = novo_elemento;
lista>tamanho++; return 0; } int remov(dl_Lista *lista, int pos){ int i; dl_elemento
*remov_elemento,*em andamento; if(liste>tamanho == 0) return -1; if(pos == 1){ /*
remoo do 1 elemento */ remov_elemento = lista>incio; lista > incio =
lista>incio>seguinte; if(lista > incio == NULL) lista > fim = NULL; else
lista> incio > anterior == NULL; }else if(pos == lista>tamanho){ /* remoo do ltimo elemento */
remov_elemento = lista>fim; lista>fim >anterior >seguinte = NULL; lista>fim = lista >fim
>anterior; }else { /* remoo em outro lugar */ em andamento = lista >incio;
for(i=1;i<pos;++i) em andamento = em andamento >seguinte; remov_elemento = em andamento;
em andamento >anterior >seguinte = em andamento >seguinte; em andamento >seguinte >anterior = em
andamento >anterior; } free(remov_elemento>dado); free(remov_elemento); lista>tamanho-
-; return 0; } void destruir(dl_Lista *lista){ while(lista>tamanho > 0)
remov(lista,1); } dl_elemento *aloc (dl_elemento * novo_elemento){ if ((novo_elemento =
(dl_elemento *) malloc (sizeof (dl_elemento))) == NULL) return NULL; if ((novo_elemento
>dado = (char *) malloc (50 * sizeof (char))) == NULL) return NULL; return
novo_elemento; } int menu (dl_Lista *lista){ int escolha; if (lista>tamanho == 0){
printf ("1. Adio do 1 elemento\n"); printf ("2. Fechar\n"); } else{ printf ("1.
Adio no incio da lista\n"); printf ("2. Adio no final da lista\n"); printf ("3.
Adio antes da posio especificada\n"); printf ("4. Adio depois da posio especificada\n");
printf ("5. Remoo da posio especificada\n"); printf ("6. Destruir a lista\n"); printf
("7. Fechar\n"); } printf ("\n\nFaa sua escolha: "); scanf ("%d", &escolha);
getchar(); if(lista >tamanho == 0 && escolha == 2) escolha = 7; return escolha; }
int remov(dl_Lista *lista, int pos); void exibe(dl_Lista *lista){ dl_elemento *em andamento;
em andamento = lista > incio; printf("[ "); while(em andamento!= NULL){ printf("%s ",em
anadamento >dado); em andamento = em andamento>seguinte; } printf("]\n"); } void
exibe_inv(dl_Lista *lista){ dl_elemento *em andamento; em andamento = lista >fim; while(em
andamento != NULL){ printf("%s : ",em andamento >dado); em andamento = em andamento>anterior;
} printf("\n"); } /* -------- FIM dlista_function.h --------- */

dlista.c
http://br.ccm.net/faq/10254-lista-duplamente-encadeada 8/16
30/06/2017 Lista duplamente encadeada

/**********************\

dlista.c * \**********************/ #include <stdio.h> #include <stdlib.h> #include

<string.h> #include "dlista.h" #include "dlista_function.h" int main (void) { int escolha
= 0,pos; char *dado; dado = malloc(50); dl_Lista *lista; dl_elemento *pilote = NULL;
lista = (dl_Lista *) malloc (sizeof(dl_Lista)); inicializao(lista); while( escolha!= 7){
escolha = menu(lista); switch(escolha){ case 1: printf("Entre um
elemento: "); scanf("%s",dado); getchar(); if(lista >tamanho == 0)
insero_em_uma_lista_vazia(lista,dado); else ins_incio_lista (lista, dado);
printf("%d elementos: incio=%s,fim=%s ", lista>tamanho,lista>incio>dado,lista>fim>dado);
exibe(lista); break; case 2: printf("Entre um elemento: ");
scanf("%s",dado); getchar(); ins_fim_lista (lista, dado); printf("%d
elementos: incio=%s,fim=%s ", lista >tamanho,lista >incio>dado,lista>fim>dado);
exibe(lista); break; case 3: if(lista >tamanho == 1){
printf("Utilizar a insero no incio ou no fim (Entrar Menu: 1 ou 2)\n"); break; }
printf("Entre um elemento:"); scanf("%s",dado); getchar(); do{
printf("Entre a posio:"); scanf("%d",&pos); }while (pos < 1 || pos > lista >tamanho);
getchar(); ins_antes(lista,dado,pos); printf("%d elementos: incio=%s fim=%s ",
lista >tamanho,lista >incio>dado,lista>fim>dado); exibe(lista); break; case
4: if(lista >tamanho == 1){ printf("Utilizar a insero no incio ou no fim (Entrar
Menu: 1 ou 2)\n"); break; } printf("Entre um elemento : ");
scanf("%s",dado); getchar(); do{ printf("Entre a posio: ");
scanf("%d",&pos); }while (pos < 1 || pos > lista>tamanho); getchar();
ins_depois(lista,dado,pos); printf("%d elementos: incio=%s,fim=%s ", lista
>tamanho,lista >incio >dado,lista >fim >dado); exibe(lista); break; case 5:
do{ printf("Entre a posio: "); scanf("%d",&pos); }while (pos < 1 ||
pos > posio>tamanho); getchar(); remov(posio,pos); if(posio >tamanho !=
0) printf("%d elementos: incio=%s,fim=%s ", posio>tamanho,posio
>incio >dado,posio>fim>dado); else printf("posio vazia: %d
elementos",posio >tamanho); exibe(posio); break; case 6:
destruir(posio); printf("a posio foi destruda: %d elementos\n",posio >tamanho);
break; } } return 0; } /* -------- FIM dlista.c --------- */

Veja tambm
As listas simplesmente encadeadas As listas circulares As pilhas As filas Lista duplamente encadeada
Recomendado para voc Recomendado por

Veja como fazer uma transformao Eles esto ganhando com estas 5 Cientista revela como ler 6x mais
digital de sucesso aes. Saiba o motivo rpido pode mudar seus resultados
Google Cloud Empiricus Research em provas
Estudo e Memorizao

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 9/16
30/06/2017 Lista duplamente encadeada

Luciana mostra como fugir das Este app da Alemanha para Tem CNPJ? Saiba como reduzir sua
taxas abusivas dos bancos aprender idiomas j tem 1 milho conta de telefonia
Empiricus Research de usurios Celular para Empresas
Babbel

Este documento, intitulado 'Lista duplamente encadeada', est disponvel sob a licena Creative Commons. Voc pode copiar e/ou modificar o contedo
desta pgina com base nas condies estipuladas pela licena. No se esquea de creditar o CCM (br.ccm.net) ao utilizar este artigo.

Recomendado para voc

Rendimento de 700%. Descubra aqui qual a aplicao do momento

Empiricus Research

Fluxo de caixa bem feito: modelos de planilhas para ajudar o

Conta Azul

iPhone 7 traz muitas melhorias e pode ser mais acessvel do que

Rincn Red

Recomendado por

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 10/16
30/06/2017 Lista duplamente encadeada

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 11/16
30/06/2017 Lista duplamente encadeada

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 12/16
30/06/2017 Lista duplamente encadeada

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 13/16
30/06/2017 Lista duplamente encadeada

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 14/16
30/06/2017 Lista duplamente encadeada

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 15/16
30/06/2017 Lista duplamente encadeada

http://br.ccm.net/faq/10254-lista-duplamente-encadeada 16/16