1: #include <cstdlib>

2: #include <iostream>
3: #include <stdio.h>
4:
5: /**********Exemplo de implementação da estrutura de dados Lista******/
6: /*******************ANA EMILIA DE MELO QUEIROZ***********************/
7:
8: /******************DEFINIÇÃO DOS ELEMENTOS DO
MUNDO***************************/
9:
10: /******DINFINIDO O TIPO ELEMENTO QUE NESTE CASO É UM
INTEIRO******************/
11: typedef int Elemento;
12:
13: /****DEFINIÇÃO DA CAPSULA OU REGISTRO QUE VAI CONTER O ELEMENTO E O
PONTEIRO
14: PARA O PROXIMO*********/
15: typedef struct cel{
16: Elemento elem;
17: cel *prox;
18: };
19:
20: /****DEFINIÇÃO DO TIPO LISTA QUE VAI CONTER APENAS OS DOIS
PONTEIROS*********/
21: /*
22: * Uma lista pode ser definida em termos dela mesma, por exemplo
23: * Uma lista é: Uma lista nula ou Um par elemento/lista
24: **/
25: typedef struct Lista{
26: cel *cabeca;
27: cel *calda;
28: int contador;
29: };
30:
31: /******************DEFINIÇÃO DAS OPERAÇÕES***************************/
32: void inicializa_lista(Lista *lista){
33: /**
34: **1° reserva memória para o novo elemento, a função malloc tem a seguinte
35: assinatura: void *malloc(size_t size); Ela devolve um ponteiro para o
primeiro
36: byte de uma região de memória de tamanho size que foi alocada; Caso não
haja
37: memória suficiente para ser alocada malloc devolve um ponteiro nulo, logo
deve
38: *ser feita
39: a verificação do retorno não nulo do ponteiro
40: */
41:
42: if(( lista->cabeca = (cel*)malloc(sizeof(cel))) == NULL){
43: printf("Erro de alocação de memória");
44: exit(1);
45: }
46: /**
47: * 2º Caso a primeira operação seja sucesso, lista->cab estará apontando
para
48: o primeiro byte de memória]
49: onde começa a área alocada de tamanho cel;
50: 3º Em seguida o próximo da cabeça deve apontar para nulo
51: 4º e o ultimo aponta para a cabeça da lista;
52: **/
53: lista->cabeca->prox = NULL;
54: lista->calda = lista->cabeca;
 55: lista->calda->prox = NULL;
56: /*
57: * Inicializa o elemento presente na lista
58: */
59: lista->cabeca->elem = 0;
60: lista->contador = 0;
61:
62: }
63:
64: /*
65: * Função que busca um elemento numa lista encadeada
66: * Essa função recebe como parâmetro a lista onde se deseja procurar e o
67: elemento procurado
68: */
69:
70: cel *buscar(Lista l, Elemento x){
71: /**
72: * Cria-se uma variável temporária inicializada com o primeiro elemento
da
73: * lista
74: */
75: cel *temp;
76: int cont;
77: temp = l.cabeca;
78: cont = 0;
79:
80: /**
81: * Pesquisa-se sequencialmente, elemento por elemento. O critério de
parada
82: *é encontrar um ponteiro nullo
83: */
84: while((temp->prox != NULL) && (temp->prox->elem < x)){
85: temp = temp->prox;
86: cont++;
87: }
88: return temp;
89: }
90:
91:
92: /*
93: *
94: * Função que verifica se a lista está vazia
95: */
96: int lista_vazia (Lista l) //Método que verifica se uma lista está vazia
97: {
98: /*
99: * Neste caso a função lista_vazia recebe um parâmetro que é uma
variável
100: * do tipo lista, ou seja um registro. Logo seus elementos podem ser
101: * acessados por meio do operador ponto "."
102: */
103: return l.cabeca == l.calda;
104: }
105:
106: /**
107: * Função que insere um elemento na lista em ordem
108: * Lista l: parâmetro utilizado para receber o endereço da lista na qual
será
109: * colocado o novo elemento
110: * Informação x: parâmetro utilizado para receber o novo elemento do tipo
Elemento
111: */
112:
113: void insere (Lista *l, Elemento x) //insere um Elemento x na lista em
ordem
114: {
115: /*
116: * Declaração de variáveis do tipo ponteiro para um registro do tipo cel;
117: * p: variável que será utilzada como temporária para percorrer a lista
118: * a: variável que será utilizada para receber o endereço de memória da
119: * nova área reservada para o novo elemento x;
120: */
121:
122: cel *p, *a;
123: /*
124: * Atribuindo-se a cabeça da lista a variável temporária p;
125: * Com essa atribuição a cabeça da lista não será perdida, a variável
cabeça
126: * continua apontando para a mesma área de memória, a qual denota a
primeira
127: * posição da lista; enquanto que a variável p irá se modificar ao longo
da
128: * operação de percorrer a lista.
129: */
130:
131: p = l->cabeca;
132:
133: /*
134: * Resevando a nova área de memória para a variável a;
135: * É aconselhavel que essa operação de reserva de memóaria seja feita
dentro de
136: * uma verificação de validade de retorno;
137: * A função malloc devolve um ponteiro do tipo void para o primeiro byte
de memória
138: * que irá apontar para uma área de memória do tipo cel. Por isso, se
faz necessário o
139: * uso do cast, para denotar que o tipo esperado de retorno seja um
ponteiro do tipo cel
140: * e não do tipo void.
141: */
142:
143: if(( a = (cel*)malloc(sizeof(cel))) == NULL){
144: printf("Erro de alocação de memória");
145: exit(1);
146: }
147: /*
148: * Após a alocação correta da área de memória reservada para o novo
elemento
149: * deve-se fazer a verificação da condições de inserção do item na lista,

150: * segundo a política que está sendo utilizada para fazer tal inserção,
151: * ou segundo algum critério específico do domínio
152: * como por exemplo, as regras do jogo 10, 20, 30.
153: * Neste caso tem-se duas situações:
154: O novo elemento será inserido
155: 1) Na lista vazia
156: 2) Numa lista não vazia
157: * Cada uma dessas situações deve ser tratada pelo algoritmo
158: */
159:
160: /*
161: * Situação 1) Primeiro elemento da lista
162: */
163:
164: /*
165: * A função lista vazia recebe como parâmetro um elemento do tipo lista.
166: * A função insere recebe como parâmetro um elemento do tipo ponteiro
para lista
167: * logo na chamda da função lista vazia deve ser aplicado o operador *
para
168: * recuperar o conteúdo que está sendo apontado pela variável l
169: */
170: if(lista_vazia(*l)){ // Se a lista está vazia
171: a->elem = x;
172: a->prox = l->calda->prox;
173: // Essa linha é o mesmo que a->prox = NULL, pois na inicalização
174: //l->calda->prox = NULL
175: l->calda->prox = a;
176: // linha que permite o encademento da nova capsula a pré-existente.
177: l->calda = a; // A calda apontará para o novo elemento
178: }else{
179: /*
180: * Situação 2) A lista não está vazia
181: * Se a lista não está vazia o elemento pode já está dentro da
lista
182: * Para inserir em ordem é necessário verificar se o elemento já
existe
183: * na lista. A função buscar está sendo usada para recuperar o
elemento
184: * caso ele exista. Ela recebe como parâmetrto o conteúdo apontado
pela
185: * variável l e um elemento do tipo Elemento ou inteiro
186: */
187: p = buscar(*l, x);
188: /*
189: * Se o resultado da busca for infrutífero
190: * A verificação está sendo feita em cima do proximo, pois
finalizada a
191: * busca e não sendo encontrado o elemento p estará apontando para
um
192: * elemento que é diferente de NULL Logo a verificação da nulidade
se
193: * dá sobre o proximo de p.
194: */
195: if (p->prox==NULL)
196: { a->elem = x;
197: a->prox = l->calda->prox;
198: l->calda->prox=a;
199: l->calda = a;
200: }else
201: { /*
202: * Caso o proximo elemento de p seja diferente de NULL então
203: * o novo elemento será colocado no meio da lista
204: */
205: a->elem = x;
206: a->prox = p->prox;
207: p->prox=a;
208: }
209: }
210: l->contador++;
211: }
212:
213: /*
214: * Função que remove o elemento que foi passado como parâmetro da lista
215: * A função recebe dois parâmetros: um elemento do tipo ponteiro para list,
216: * e um elemento do tipo ponteiro para elemento
217: */
218:
219: void remove(Lista *l, Elemento *x) //Remove o elemento x da lista.
220: { cel *p, *q;
221:
222: /**
223: * Função que recebe um elemento do tipo lista, logo o operador * deve
224: * ser aplicado ao parâmetro l a fim de recuperar seu conteúdo, que é
um re
225: * registro do tipo lista
226: */
227: if (lista_vazia(*l))
228: printf(" A LISTA ESTA VAZIA PARA REMOVER \n");
229: else {
230: /**
231: * Função que recebe dois parâmetros: um do tipo lista e outro do
tipo
232: * Elemento logo o operador * deve ser aplicado aos dois parâmetro a
fim
233: * de recuperar os seus conteúdos
234: *
235: */
236:
237: p = buscar(*l,*x);
238: /*
239: * Se o proximo de p for igual a NULL significa dizer que
chegou a
240: * final da lista e não foi encontrado nenhum
241: * elemento cuja chave é igual a x;
242: */
243: if (p->prox==NULL)
244: /*
245: * Colocando o valor -1 no parâmetro que foi passado por
referência
246: */
247: *x=-1;
248: /*
249: * Se caso contrário o proximo do elemento não for nulo,
250: * verifica-se se a chave do elemento é igual a valor que
está
251: * sendo passado por referência
252: */
253:
254: else if (p->prox->elem == *x)
255: {
256: /*
257: * Se o elemento for encontrado, então será
necessário
258: * usar a variável temporária q para guardar a
posição
259: * de memória que será liberada
260: * desfazendo a ligação antiga e incorporando a
nova
261: * ligação
262: */
263: /*
264: * O elemento do conjunto que será retirado será
265: * p->prox
266: * logo uma variável temporária irá apontar para
ela
267: */
268: q = p->prox;
269: /*
270: * Em seguida o antigo link que existia entre p
e o
271: * elemento encontrado é desfeito e assim p-
>prox
272: * passa a apontar para o elemento sucessor de q;
273: */
274: p->prox=q->prox;
275: /*
276: * Finalmente verifica-se se o elemento removido
é o
277: * ultimo ou a calda
278: */
279:
280: if (q == l->calda)
281: /*
282: * Caso seja a calda passa a ser o elemento p;
283: * antecessor do que foi removido
284: */
285:
286: l->calda=p;
287: /*
288: * Finalmente libera-se a área de memória usada
pelo
289: * elemento que foi removido
290: */
291:
292: free(q);
293: }
294: /*
295: * Mesmo que a busca retorne algum elemento não
é
296: * garantido que esse seja igual a chave;
297: * A busca da mameira que foi implementada pode
298: * retornar um elemento maior ou igual ao
procurado
299: * logo essa verificação de igualdade está sendo
feita
300: * na função remove, e caso esse valor seja
maior
301: * do que o procurado é colocado -1 no parâmetro
x que
302: * foi passado por referência.
303: *
304: */
305: else *x=-1;
306: }
307: } //Fim do Remove
308:
309: /*
310: * Função que exibe todos os elementos da lista na tela.
311: */
312: void imprimir_lista(Lista l)
313: { cel *p;
314: if (lista_vazia(l))
315: printf("A LISTA ESTA VAZIA NAO EXISTEM ELEMENTOS PARA MOSTRAR
\n\n");
316: else
317: { p = l.cabeca->prox;
318: printf(" LISTA ENCADEADA \n");
319:
printf("=====================================================\n\n");
320: while (p !=NULL)
321: { printf("[ %d ]-->",p->elem);
322: p=p->prox;
323: }
324: printf("NULL \n \n");
325:
printf("=====================================================\n\n");
326: }
327: system("PAUSE");
328: }
329:
330: int main(int argc, char *argv[])
331: {
332: /*
333: * Declaração de uma variável do tipo lista, ou seja um elemento que é um
334: * registro que contém dois outros elementos do tipo ponteiro para
registros do
335: * tipo cel, o qual por sua vez contém um elemento do tipo inteiro e um
elemento
336: * do tipo ponteiro para cel.
337: */
338: Lista lista;
339: int elementoProcurado;
340:
341: /*
342: * Passa o endereço da variável lista como parâmetro para a função que irá
343: * inicializar a lista
344: **/
345: inicializa_lista(&lista);
346: /*
347: * Para verificar se a lista está vazia, passa-se a variável lista como
348: * parâmetro para a função
349: * que irá verificar se a cabeça é igual a calda;
350: */
351: lista_vazia(lista);
352: /*
353: * A função buscar recebe como parâmetro a lista e o elemento a ser buscado
354: * e devolve como retorno um ponteiro para um elemento do tipo cel
355: */
356: insere (&lista, 15);
357: insere (&lista, 17);
358: insere (&lista, 16);
359: elementoProcurado = 16;
360: imprimir_lista(lista);
361: remove(&lista, &elementoProcurado);
362: imprimir_lista(lista);
363: system("PAUSE");
364: return EXIT_SUCCESS;
365: }
366: