Listas com Ponteiros

Listas encadeadas Listas circulares

Listas Simplesmente Encadeadas

A figura mostra como seria uma lista usando ponteiros para encadear os elementos da lista.

O ponteiro pt aponta para o nó inicial da lista. Cada nó está representado por um retângulo dividido em duas

partes. Uma das partes contém a informação e a outra o ponteiro para

o próximo nó. Observar que o no último nó a seta aponta para a terra, que

indica fim da lista.

Listas Simplesmente Encadeadas

A função listar mostra como percorrer uma lista encadeada simples.

void listar (struct tElemento *ptlista) {

int i=0; struct tElemento *pont;

pont = ptlista; while (pont) { printf("Elemento %d = %d\n", i++, pont->info); pont = pont->prox; }}

Listas Simplesmente Encadeadas

Outras funções relevantes em listas são: busca, inserção e remoção.

Para facilitar a busca e localização dos nós a serem removidos e das posições de inserção modificaremos a lista para incluir o que costuma ser chamado de nó cabeça.

Neste tipo de lista o primeiro nó não irá conter informação, ele apenas faz com que o algoritmo de busca não necessite diferenciar o primeiro nó dos demais.

Listas Simplesmente Encadeadas A função de busca a seguir é simples e tem como protótipo ponteiros para

ponteiros. O primeiro **ant aponta para o nó anterior ao nó procurado e **ponte aponta para o nó procurado.

void busca ( tElemento *ptlista, int x, tElemento **ant, tElemento **ponte) { /* *ptlista ponteiro para inicio da lista x elemento a ser procurado **ant ponteiro para ponteiro do elemento anterior **pont ponteiro para ponteiro do elemento procurado */

tElemento *ptr; *ant = ptlista; /* aponta no anterior */ *ponte = NULL; /* aponta no procurado, se nao achar retorna nulo */ ptr = ptlista->prox; /* aponta no procurado */

while (ptr) { /* procura enquanto houver chance */ if (ptr->info < x) { /* ainda nao chegou no no */ *ant = ptr; ptr = ptr->prox; } else { /* pode ser aqui */ if (ptr->info == x) *ponte = ptr; /* achou */ ptr = NULL; /* nao estava na lista */ } }}

Listas Simplesmente Encadeadas

A figura a seguir mostra a remocao de lista encadeada com nó cabeça e sua respectiva função.

void remover ( tElemento *ptlista) { int x; char linha[80]; tElemento **ant, **pont;

printf("Valor a remover? "); fgets(linha, 80, stdin); sscanf(linha, "%d", &x);

ant = ( tElemento **) malloc(sizeof ( tElemento *)); pont = ( tElemento **) malloc(sizeof ( tElemento *)); busca (ptlista, x, ant, pont); if (*pont) { (*ant)->prox = (*pont)->prox; printf("Retirei %d\n", (*pont)->info); free(*pont); } else puts("Nao achei na lista.");}

Listas Simplesmente Encadeadas O algoritmo de inserção tem o seguinte código: void inserir ( tElemento *ptlista) { tElemento *pt, /* ponteiro para o novo no a inserir */ **ant, /* ponteiro para ponteiro na lista */ **pont; /* ponteiro para ponteiro do no anterior */ int x; char linha[80]; printf("Valor a inserir? "); fgets(linha, 80, stdin); sscanf(linha, "%d", &x); ant = ( tElemento **) malloc(sizeof ( tElemento *)); pont = ( tElemento **) malloc(sizeof ( tElemento *));

busca (ptlista, x, ant, pont); if (!*pont) { pt = ( tElemento *) malloc(sizeof( tElemento)); pt->info = x; pt->prox = (*ant)->prox; (*ant)->prox = pt; } else puts("Elemento ja existe na tabela."); }

Exercício

Escreva um programa em C que implemente todas as funções apresentadas e as disponibilize em um menu.

Listas circulares

O algoritmo de busca em uma lista encadeada pode ser melhorado se modificarmos a lista de modo que ela passe a ser circular como está mostrado a seguir:

Neste caso o algoritmo não tem como testar o final da lista. A solução é armazenar o dado que se está procurando no nó cabeça.

Ao término do algoritmo a chave é sempre encontrada, e pode-se descobrir se ela pertencia ou não a lista pelo ponteiro que foi dado como resposta.

Caso o ponteiro termine apontando para o nó cabeça, podemos afirmar que o elemento não se encontra na lista.

Listas circulares

As funções de procura, inserção e remoção em uma lista circular encadeada serão mostrados a seguir.

O algoritmo de busca aparece como parte das rotinas de inserção e remoção.Nestas funções primeiro se procura o elemento depois se decide o que fazer.

No algoritmo de busca, caso o elemento já exista na lista, não há nada a fazer, caso contrário o ponteiro ant aponta para o elemento após o qual o novo elemento será inserido.

Na função de remoção, a busca termina apontando para o elemento a ser removido (ponteiro pont) ou com a indicação que o elemento não se encontra na lista (pont apontando para o nó cabeça).

Listas circulares

Definição da estrutura:

struct tElemento { int info; struct tElemento *prox; };

char menu(); struct tElemento *cria_no();

Listas circulares

Função menu:

char menu () { char opcao, linha[80];

puts("Qual a sua opcao?"); puts("[L]istar, [I]nserir, [R]emover, [S]air"); gets(linha); sscanf(linha, "%c", &opcao); return tolower(opcao); }

Listas circulares

Função listar:

void listar (struct tElemento *ptlista) { int i=0; struct tElemento *pont; pont = ptlista->prox; while (pont != ptlista) { printf("Elemento %d = %d\n", i++, pont->info); pont = pont->prox; } }

Listas circulares Função insere:void insere (struct tElemento *ptlista, int valor) { struct tElemento *pont, *ant, *pt; /* Aqui esta o algoritmo de busca em uma lista circular */ ant = ptlista; pont = ptlista->prox; ptlista->info = valor; while (pont->info < valor) { ant = pont; pont = pont->prox; } if (pont->info == valor && pont != ptlista) puts("Elemento ja existe na tabela."); else { pt = cria_no(); pt->info = valor; pt->prox = pont; ant->prox = pt; } }

Listas circulares Função remove:void meu_remove (struct tElemento *ptlista, int valor) { struct tElemento *pont, *ant; ant = ptlista; pont = ptlista->prox; ptlista->info = valor; while (pont->info < valor) { if (pont->info < valor) { ant = pont; pont = pont->prox; } } if (pont->info == valor && pont != ptlista) { ant->prox = pont->prox; free(pont); } else puts("Elemento nao existe na tabela."); }

Listas circulares

Função cria nó:

struct tElemento *cria_no() { struct tElemento *pt; if (( pt = (struct tElemento *) malloc(sizeof(struct tElemento)) )

== NULL ) { puts("Nao há espaço."); exit(1); } pt->info = -1; pt->prox = NULL; return pt; }

Exercício

Escreva um programa em C que implemente todas as funções apresentadas.

PilhasUma pilha é uma lista em que os elementos são inseridos e

removidos sempre pelo topo da pilha. A figura mostra

como se processam operações que envolvem acesso a uma pilha.

Pilhas - Listar

Uma imagem simples pode ilustrar o funcionamento das pilhas.Considere um restaurante onde os clientes do tipo self-service.Neste restaurante, para se servirem, os clientes retiram pratos e os

empregados colocam pratos limpos em uma pilha. Observe que os empregados colocam pratos no topo da pilha, o

mesmo local de onde os clientes retiram os pratos.A função abaixo lista o conteúdo de uma pilha:

void listar (int item[], int topo) { /* Esta rotina esta aqui somente para depuracao */ int i; for (i=0; i<topo; i++) printf("elemento %d = %d \n", i, item[i]);}

Pilhas - Inserir

A função abaixo insere no topo da pilha:

void insere (int item[], int *topo) { int t; char linha[80]; printf("Valor a inserir? "); gets(linha); sscanf(linha, "%d", &t); if (*topo < MAX) { *topo=*topo+1; item[*topo] = t; printf("Topo = %d\n", *topo); } else puts("Pilha cheia.");}

Pilhas - Remover

A função a seguir retira um elemento do topo da pilha:

void meu_remove (int item[], int *topo) { int x; if (*topo != -1) { x = item[*topo]; *topo = *topo-1; printf("Retirei %d da pilha.\n", x); } else puts("Lista vazia"); }

Exercícios

1. Implemente um programa em C que utilize as funções descritas anteriormente para realizar operações em Pilhas.

2. Adapte o programa anterior para que o mesmo realize operações em Filas, isto é, insira pelo topo e retire pelo fundo.

3. Escreva um programa que, utilizando a estrutura de pilhas, avalie uma expressão em notação polonesa reversa.