View
217
Download
0
Category
Preview:
Citation preview
1
- Estruturas e aplicações
MCTA028 – Programação Estruturada
Luiz Rozante
3Q-2018
Material preparado a partir de slides dos profs. Jesús Mena-Chalco e Fabrício Olivetti
2
Estruturas (=registros)
3
Linguagem C: Tipos de dados
Tipos de dados primários.Tipos de dados derivados.Tipos definidos pelo usuário.
(*) Fonte: http://www.studytonight.com/c/datatype-in-c.php
Para definir e usar um tipo de usuário
Definição
Declaração
Acesso
Em C, structs permitem definir tipos de dados como umacomposição de tipos já existentes.
O uso de tipos de usuário exige três “passos”:
Definição de tipo de usuário
Podemos definir (“dizer como é”) um tipo novo usando tipos já existentes (definidos ou pré-definidos).
Forma geral:
struct nome_tipo { nome_tipo_1 nome_membro_1; nome_tipo_2 nome_membro_2; ... nome_tipo_k nome_membro_k; };
Declaração de variáveis de tipo de usuário
Declaramos uma variável de tipo definido (de usuário) da mesma forma que declaramos uma de tipo pré-definido.
struct nome_tipo nome_var;
Definição e declaração de tipos de usuário com a cláusula typedef (redefinidor de nomes de tipo).
Forma geral:
typedef struct {
nome_tipo_1 nome_membro_1;
nome_tipo_2 nome_membro_2;
...
nome_tipo_k nome_membro_k;
}nome_tipo_novo;
nome_tipo_novo nome_var;
definição
declaração
Acesso a variáveis de tipo de usuário
O acesso aos membros (campos) de variáveis declaradas a partir de tipo de usuário (definido) é feito através do operador de acesso:
– ponto (´.´), – seta (' -> '), se ponteiro para estrutura (registro).
9
Estruturas
1. #include <stdio.h>2.3. struct ALUNO { //Definição da estrutura4. float nota;5. int cod;6. char conceito;7. };
1. void main() {2. int i;3. struct ALUNO jose, ana; // Declara variáveis4. struct ALUNO turma[7]; // do tipo ALUNO5. jose.nota = 7.0; // Acessa membros da6. jose.cod = 1212; // variável jose7. if (jose.nota < 7.0) { 8. jose.conceito = ‘R’; 9. } 10. else {11. jose.conceito = ‘A’; 12. }13. 14. for (i=0 ; i<=6 ; i++) {15. turma[i].cod = 100 + i; • turma[i].nota = 0.0;1. }2. }
1. #include <stdio.h>2. struct FICHA { //Definição da estrutura FICHA3. char nome[40];4. int cod;5. float salario;6. };
1. void le_cadastro();
1. /* declara um vetor tipo FICHA */ 2. struct FICHA cadastro[100];
1. void main() { le_cadastro(); }
1. void le_cadastro() {2. int i;3. for (i=0 ; i<=99 ; i++) {4. printf(“Nome = “);5. gets(cadastro[i].nome);6. printf(“\n “);7. printf(“Código = “);8. scanf(“%d\n”, &cadastro[i].cod);• printf(“\n “);1. printf(“Salário = “);• scanf(“%f\n”, &cadastro[i].salario);1. }2. }
1)
1. #include <stdio.h>2. #include <conio.h>3. struct DATA { //Definição da estrutura DATA4. int dia;5. char mes[10];6. int ano;7. };
1. struct VENDA { //Definição da estrutura VENDA 2. int cod;3. int qtde;4. float preco;5. struct DATA dt_venda;6. };
1. void impr_venda();2. void impr_vendaS();
1. /* inicialização da variável x tipo VENDA */2. struct VENDA x={12,10,23.4,{5,”Mar”,2002}};
1. /* declaração de uma matriz tipo VENDA */2. struct VENDA reg_venda[1000];
1. void main() {2. impr_venda();3. impr_vendaS();4. }
2)
24. void impr_venda() {25. printf(“Cod= %d\n”, x.cod);26. printf(“Qtde= %d\n”, x.qtde);27. printf(“Preço= %f\n”, x.preco);28. printf(“Data da venda = %d/%s/%d ”,29. x.dt_venda.dia, 30. x.dt_venda.mes, 31. x.dt_venda.ano);32. }
24. void impr_vendaS() {25. int i;26. for (i=0 ; i<=999 ; i++) {27. printf(“Cod = %d\n”,reg_venda[i].cod);28. printf(“Qtde= %d\n”,reg_venda[i].qtde);29. printf(“Preço=%f\n”,reg_venda[i].preco);30. printf(“Data da venda = %d/%s/%d ”,31. reg_venda[i].dt_venda.dia, 32. reg_venda[i].dt_venda.mes, 33. reg_venda[i].dt_venda.ano);34. }35. }
2)
14
Estruturas
Operador de acesso indireto
Tipos abstratos de dados (TAD)
Para resolver um problema é necessário escolher uma abstração da realidade, em geral mediante a definição de um conjunto de dados que representa a situação real
A seguir, deve ser escolhida a forma de representar esses dados
A escolha da representação dos dados é determinada, entre outras, pelas operações a serem realizadas sobre os dados
15
Exemplo de TAD: Listas Lineares ● Sequência de zero ou mais itens x1, x2, ... , xn, na qual
xi é de um determinado tipo e n representa o tamanho da lista linear
● Sua principal propriedade estrutural envolve as posições relativas dos itens em uma dimensão
– Assumindo n >= 1, x1 é o primeiro item da lista e xn é o último item da lista
– xi precede xi+1 para i = 1, 2, . . ., n – 1– xi sucede xi-1 para i = 2, 3, . . ., n – o elemento xi é dito estar na i-ésima posição da lista
16
Listas Lineares
● Muitas aplicações
● Principal aplicação: representação interna de conjuntos.
17
Listas Lineares: Implementações
● Pode ser implementada de diferentes maneiras– Estática
● todo o espaço de memória a ser utilizado (para armazenar os itens) é reservado (alocado) no início da execução do programa ou módulo
● esse espaço de memória permanece reservado durante toda a execução do programa, independente de estar sendo efetivamente utilizado ou não
– Dinâmica● o espaço de memória a ser utilizado (para armazenar
os itens) pode ser reservado (alocado) no decorrer da execução de um programa ou módulo, quando for efetivamente necessário
● o espaço reservado pode ser liberado durante a execução do programa, quando não for mais necessário
18
Listas Lineares - Estática
● Podem dispor os seus elementos de maneira
– Seqüencial: os itens ficam, necessariamente, em sequência (um ao lado do outro) na memória
– Encadeada: os itens não estão, necessariamente, em posições de memória adjacentes (sequência lógica ou virtual)
19
Listas Lineares – Estática Seqüencial● Os itens da lista são armazenados
em posições contíguas de memória● A lista pode ser percorrida em
qualquer direção● A inserção de um novo item pode ser
realizada após o último item com custo constante O(1)
● A inserção de um novo item no meio da lista requer um deslocamento de todos os itens localizados após o ponto de inserção O(n)
● Retirar um item do início da lista requer um deslocamento de itens para preencher o espaço deixado vazio O(n)
20
ItensÍndices
X1
X2
Xn
MaxTam
1
2
n
.
.
.
.
.
.
Listas Lineares – Estática Seqüencial (TAD)
● Para a definição de um TAD, o conjunto de operações a ser definido depende de cada aplicação
● Exemplos:– 1. Criar uma lista linear vazia– 2. Inserir um novo item imediatamente após o i-ésimo item– 3. Retirar o i-ésimo item– 4. Localizar o i-ésimo item para examinar e/ou alterar o
conteúdo de seus componentes.– 5. Combinar duas ou mais listas lineares em uma lista única– 6. Partir uma lista linear em duas ou mais listas– 7. Fazer uma cópia da lista linear– 8. Ordenar os itens da lista em ordem ascendente ou
descendente, de acordo com alguns de seus componentes– 9. Pesquisar a ocorrência de um item com um valor
particular em algum componente21
Listas Lineares – Estática SeqüencialVantagens/Desvantagens
● Vantagens– acesso direto indexado a qualquer elemento da lista – tempo constante para acessar o i-ésimo item - dependerá
somente do índice
● Desvantagens – movimentação quando o item é eliminado/inserido– tamanho máximo pré-estimado
● Diante disso, quando usar?– listas pequenas – inserção/remoção no fim da lista – tamanho máximo bem definido
22
MC-1424 Algoritmos e Estruturas de Dados I - 2° trimestre de 2009
Listas Lineares – Estática Seqüencial Programa em C
#include <stdio.h>
#include <stdlib.h>
#define TAM_MAX 5
#define NULO -9999999
int insere (int lista[], int *n, int chave);
int remove_final (int lista[], int *n);
int remove_inicio (int lista[], int *n);
int imprime (int lista[], int n);
char menu(void);
main()
{
int lista[TAM_MAX];
int num_atual = 0;
...
}
23
Listas Lineares – Estática Seqüencial Função: Inserir no final
int insere (int lista[], int *n, int chave)
{
if (*n == TAM_MAX) return (NULO);
lista[(*n)++] = chave;
return (0);
}
24
Listas Lineares – Estática Seqüencial Função: Remover do final
int remove_final (int lista[], int *n){ if (*n == 0) return (NULO); return (lista[--(*n)]);}
25
Listas Lineares – Estática Seqüencial Função: Remover do início
int remove_inicio (int lista[], int *n){ int i, primeiro; if (*n == 0) return (NULO); primeiro = lista[0]; for (i=1; i < *n; i++) lista[i-1]= lista[i]; (*n)--; return primeiro;} Complexidade: (?)
26
Listas Lineares – Estática Seqüencial Função: Imprimir lista
int imprime (int lista[], int n){ int i; if (n == 0) printf ("Lista vazia!\n"); else { printf ("%d elementos na lista\n", n); for (i=0; i < n; i++) printf ("Elemento %d = %d\n", i+1, lista[i]);
} return (0);}
27
Listas Lineares – Estática Seqüencial Função: Busca lista
Exercício: Como seria a função de busca na lista ?
28
Listas Lineares – Estática Seqüencial Função: Busca lista
Exercício: Como seria a função de busca na lista ?
int busca (int lista[], int n, int chave){int i, achou = 0;
if (n == 0) return(achou); else { for(i = 0;i < n; i++){ if(lista[i] == chave) achou = 1; } return (achou);}
29
Algumas implementações possíveis
● Na forma Dinâmica como ponteiros de nós, a lista pode ser implementada de várias formas, por exemplo:
– Lista Encadeada Simples
– Lista com Descritor
– Lista Duplamente Encadeada
30
Lista Dinâmica Encadeada● Numa lista encadeada, um espaço de memória é alocado para cada
novo elemento (item) inserido na estrutura– O espaço total de memória é proporcional ao número de
elementos– Não há garantia de que os elementos da lista ocuparão espaço de
memória contíguo não há acesso direto aos elementos● Para percorrer todos os elementos da lista é necessário guardar o
seu encadeamento– Armazena-se, junto com a informação de cada elemento, um
ponteiro para o próximo elemento da lista
31
Info1 Info2 Info3
Prim
NULL
Lista Dinâmica Encadeada
32
● Os itens da lista são nós com um dos componentes destinado a guardar o endereço do nó sucessor
● Ex: L = anta, cabra, gato, pato, rato
●
● onde cada nó é:
– Diz-se que cada nó aponta para o próximo nó– O próximo do último nó é um apontador para NULL– É necessário um apontador para o primeiro nó da lista
Lista Dinâmica Encadeada Estrutura auto-referenciada
33
● Exemplo: o nó de uma lista para armazenar números inteiros pode ser representado em C
struct {
int info;
struct no *proximo;
}no;
● Estrutura auto-referenciada possui um campo que é um ponteiro para uma próxima estrutura do mesmo tipo
● Essa estrutura representa um nó da lista, e a estrutura de lista encadeada é representada pelo ponteiro para o primeiro elemento
Lista Dinâmica Encadeada TAD
● Para a definição de um TAD, o conjunto de operações a ser definido depende de cada aplicação
● Exemplos:– 1. Criar uma lista vazia– 2. Verificar se a lista está vazia– 3. Inserir um novo item no início da lista– 4. Inserir um novo item no final da lista– 5. Retirar um item da lista no começo– 6. Retirar um item da lista no fim– 7. Buscar um item na lista– 8. Imprimir os itens da lista– 9. Determinar o comprimento da lista– 10. Liberar a lista– ...
34
Lista Dinâmica Encadeada Simples Análise de algumas operações
● Função de inserção no início da lista– Para cada elemento inserido é necessário alocar dinamicamente
a memória necessária– Nota importante: o ponteiro que representa a lista deve ter seu
valor atualizado
35
Info1 Info2 Info3
Prim
NULL
Novo
Lista Dinâmica Encadeada Simples Análise de algumas operações
● Função que retira um elemento da lista– Duas situações tem que ser consideradas
● (a) Remoção no início da lista● (b) Remoção no “meio“ da lista
36
Info1 Info2 Info3
Prim
NULL
Info1 Info2 Info3
Prim
NULL
(a)
(b)
Lista encadeada (código): tipos e ponteiros
1. #include <stdio.h>2. #include <stdlib.h>
3. typedef struct {4. int valor;5. struct nodo *prox;6. }nodo;
7. nodo *prim;8. nodo *p;9. nodo *q;
10. void cria_lista_vazia();11. void verifica_se_lista_vazia();12. void inclui_inicio(int x);13. void inclui_fim(int x);14. void imprime_lista();15. void remove_inicio();16. void remove_fim();
Código: main
1. int main(int argc, char** argv) {2. cria_lista_vazia();3. printf("\n");4. verifica_se_lista_vazia();5. inclui_inicio(10);6. inclui_inicio(12);7. inclui_fim(30);8. inclui_fim(40);9. remove_inicio();10. remove_fim();11. imprime_lista();12. return (EXIT_SUCCESS);13.}
Código: cria lista vazia
1. void cria_lista_vazia(){
2. prim = NULL;
3. printf("criei lista vazia\n");
4. }
Código: verifica se é vazia
1. void verifica_se_lista_vazia(){2. if (prim == NULL){3. printf("a lista está lista vazia\n");4. printf("prim = %p \n", prim);5. }6. else {7. printf("a lista NÃO está vazia");8. printf("prim = %p \n", prim);9. }10.}
Código: inserir no início
1. void inclui_inicio(int x){
2. if ((p = (struct nodo*) malloc(sizeof(nodo))) == NULL) {3. printf(" nao consegui alocar memoria para p\n");4. exit(0);5. }
6. p->prox = prim;7. p->valor = x;8. prim = p;9. }
Código: inserir no fim
1. void inclui_fim(int x){
2. if ((p = (struct nodo*) malloc(sizeof(nodo))) == NULL) {3. printf(" nao consegui alocar memoria para p\n");4. exit(0);5. }
6. q = prim;7. while (q->prox != NULL){8. q = q->prox;9. }
10. p->valor = x;11. q->prox = p;12. p->prox = NULL;
13.}
Código: excluir no começo
1. void remove_inicio(){
2. p = prim->prox;
3. free(prim);
4. prim = p;
5. }
Código: excluir no fim
1. void remove_fim(){2. q = prim->prox;3. while (q->prox != NULL){4. p = q;5. q = q->prox;6. }7. free(q);8. p->prox = NULL;9. }
Código: imprimir
1. void imprime_lista(){2. p = prim;3. do {4. printf(" %d ", p->valor);5. p = p->prox;6. }while (p->prox != NULL);7. printf(" %d ", p->valor);8. printf("\n");
9. }
Comparação entre as estratégiasEstática Seqüencial vs. Dinâmica Encadeada
46
● Quando é melhor utilizar uma implementação ou outra?
– Principais características que devem ser consideradas● A implementação estática (array) requer a
especificação do tamanho máximo da lista em tempo de compilação. Se não for possível especificar o tamanho máximo que a lista pode atingir, seria mais adequado escolher a implementação dinâmica
● A implementação estática pode desperdiçar espaço. A implementação dinâmica requer espaço para os ponteiros em cada célula. Em diferentes circunstâncias um método pode acabar utilizando mais espaço do que o outro
Comparação entre as estratégiasEstática Seqüencial vs. Dinâmica Encadeada
47
● Quando é melhor utilizar uma implementação ou outra?
– Principais características que devem ser consideradas● Algumas operações são mais custosas em uma
implementação e não na outra
– Inserção e deleção no início tempo constante na implementação dinâmica encadeada, mas tempo proporcional ao número de elementos na implementação estática
– No final tempo constante na implementação estática, mas tempo proporcional ao número de elementos na implementação dinâmica encadeada
Lista Dinâmica Encadeada Alguns Problemas
● Caracteriza-se por formar um encadeamento simples entre os elementos– Cada elemento armazena um ponteiro para o próximo elemento
da lista● Problemas dessa estratégia
– Não temos como percorrer a lista em ordem inversa de maneira eficiente
– Dificulta a retirada de um elemento da lista. Mesmo se tivermos o ponteiro para o elemento que se deseja retirar, temos que percorrer a lista para encontrar o elemento anterior
● Solução– Lista com descritor?– Lista Dinâmica Duplamente Encadeada
48
Outro exemplo de TAD: Pilhas
49
Pilhas
É a estrutura de dados mais utilizada em programação, sendo inclusive implementada diretamente pelo hardware da maioria das máquinas modernas
A idéia fundamental da pilha é que todo o acesso a seus elementos é feito por meio do seu topo
É um conceito semelhante a qualquer tipo de pilha: pratos, livros, CDs, etc
50
Pilhas (Stacks)
Estrutura de dados com a característica LIFO
LIFO: Last-In First-Out
O último a entrar é o primeiro a sair
Funcionamento
O primeiro item inserido na pilha fica no fundo, sendo o último a ser removido
Todos os itens inseridos na pilha são colocados em cima dos itens anteriores
O último item inserido na pilha é o que está no topo, sendo topo, sendo o primeiro a ser removido
51
Pilhas (Stacks)
Para que serve? Para modelar situações em que é preciso “guardar
para mais tarde” vários elementos, e “lembrar” sempre do último elemento armazenado (LIFO)
52
Pilhas (animação)
53MC-1424 Algoritmos e Estruturas de Dados I - 2° trimestre de 2009http://www.cosc.canterbury.ac.nz/people/mukundan/dsal/StackAppl.html
Características de Pilhas
Dados somente podem ser colocados no topo da pilha
Dados somente podem ser removidos do topo da pilha
Dados somente podem ser removidos do fundo da pilha se existe somente um elemento na pilha
Dados não podem ser removidos do meio da pilha sem antes remover todos os itens anteriores (do topo)
54
Operações de uma Pilha
Principais
Empilha (push) Desempilha (pop)
Auxiliares
Topo (peek) Vazia (isEmpty) Cheia (isFull) Procura (search)
55
Implementação de Pilhas
Lista Estática Seqüencial (Array)
Fácil de implementar Tamanho limitado
Lista Dinâmica Encadeada
Implementação mais complexa Sem limitação de tamanho (memória do
computador) Memória alocada dinamicamente Listas encadeadas que se insere e remove do início
são pilhas
56
Pilha em Lista Estática Seqüencial
PILHA - lista estática seqüencial que implementa pilha o elemento 0 será definido como o fundo da pilha topo da pilha: TOPO é o índice que indica a 1a. posição
livre da pilha Ppilha vazia: TOPO = 0 restrição: tamanho máximo
1o. elem.
2o. elem.
3o. elem.
4o. elem.
3
57
3
2
1
0
Pilha em C – Exemplo (1)
#define MAX 50
typedef struct pilha {
int n;
int vet[MAX];
} tipoPilha;
// Prototipos das funcoes
tipoPilha *cria(void);
void push(tipoPilha *p, int v),
libera(tipoPilha *p);
int pop(tipoPilha *p),
vazia(tipoPilha *p);
58
MC-1424 Algoritmos e Estruturas de Dados I - 2° trimestre de 2009
Pilha em C – Exemplo (1)// Funcao para criar uma pilha de dadostipoPilha *cria(void){tipoPilha *p = (tipoPilha*) malloc(sizeof(tipoPilha));p->n = 0; // Inicializa pilha com zero elementosreturn p;
}
// empilhamento (push) de elementosvoid push(tipoPilha *p, int v){if (p->n == MAX) {printf("Capacidade da pilha estourou.\n");exit(1);}/*Insere elemento na proxima posicao livre*/p->vet[p->n] = v;p->n++;
}
59
60MC-1424 Algoritmos e Estruturas de Dados I - 2° trimestre de 2009
Pilha em C – Exemplo (1)// Funcao para desempilhamento (pop) de elementosint pop(tipoPilha *p){int v;if (vazia(p)) {printf("tipoPilha vazia.\n");return -1;}v = p->vet[p->n-1];p->n--;return v;
}// Funcao que verifica se uma pilha esta vaziaint vazia(tipoPilha *p){return (p->n == 0);
}
Pilha em C – Exemplo (1)
/* Funcao que libera espaco em memoria alocado para a pilha */
void libera(tipoPilha *p){free(p);
}
61
Topo – agora é um ponteiro para o topo da pilha Pilha vazia: Topo= NULL
não possui restrição de tamanho máximo
Pilhas em lista encadeada
62
Pilha em lista encadeada
empilha
desempilhanovo elemento
63
Aplicações de Pilhas
Aplicações diretas Histórico de páginas visitadas em um navegador
Web Desfazer uma seqüência de ações em um editor de
textos (Ctrl+Z) Realizar cálculos usando a notação polonesa (por
exemplo, calculadoras HP) Chamada de procedimentos em Sistemas
Operacionais
Aplicações indiretas Estrutura de dados auxiliar para algoritmo
64
Exemplo de aplicação
Calculadora pós-fixada
Notação para expressões aritméticas – infixa = operador entre os operandos (1-2)*(4+5)
pós-fixa = operador após operandos 1 2 – 4 5 + * pré-fixa = operador antes dos operandos * - 1 2 + 4 5
Exemplo:
calculadora HP científica usa notação pós-fixa
65
Exemplo de aplicação
Calculadora pós-fixada
Avaliação de expressões aritméticas pós-fixadas: cada operando é empilhado numa pilha de valores quando se encontra um operador desempilha-se o número apropriado de operandos realiza-se a operação devida empilha-se o resultado
Exemplo: avaliação da expressão 1 2 – 4 5 + * Tipo de dados abstratos (TDA)
66
Tipos abstratos de dados (TAD)
A idéia é encapsular (esconder) de quem usa um determinado tipo a forma concreta com que ele foi implementado
Para isso, separa-se a declaração e a implementação do TAD em dois arquivos:
- NomeDoTAD.h : com a declaração
- NomeDoTAD.c : com a implementação
O programa ou outros TADs que utilizam o seu TAD devem dar um #include no arquivo .h
67
Tipos abstratos de dados (TAD)
Exemplo:
Vamos implementar a estrutura de um TAD em ContaBancaria, com os campos número e saldo onde os clientes podem fazer as seguintes operações:
• Iniciar uma conta com um número e saldo inicial
• Depositar um valor
• Sacar um valor
• Imprimir o saldo
68
Tipos abstratos de dados (TAD)
ContaBancaria.h
/* definição do tipo */typedef struct { int numero; double saldo;} ContaBancaria;
/* declaração das funções */void Inicializa(ContaBancaria* conta, int numero, double saldo);
void Deposito (ContaBancaria* conta, double valor);
void Saque (ContaBancaria* conta, double valor);
void Imprime (ContaBancaria conta);
69
MC-1424 Algoritmos e Estruturas de Dados I - 2° trimestre de 2009
Tipos abstratos de dados (TAD)ContaBancaria.c
#include <stdio.h>#include "Contabancaria.h"void Inicializa(ContaBancaria* conta, int numero, double saldo){ (*conta).numero = numero; (*conta).saldo = saldo;}void Deposito (ContaBancaria* conta, double valor){ (*conta).saldo += valor;}void Saque (ContaBancaria* conta, double valor){ (*conta).saldo -= valor;}void Imprime (ContaBancaria conta){printf("Numero: %d\n", conta.numero);printf("Saldo: %f\n", conta.saldo);}
70
Tipos abstratos de dados (TAD)
int main (int argc, char **argv){ ContaBancaria conta1; Inicializa(&conta1, 918556, 300.00); printf("\nAntes da movimentacao:\n "); Imprime(conta1); Deposito(&conta1, 50.00); Saque(&conta1, 70.00); printf("\nDepois da movimentacao:\n "); Imprime (conta1);}
71
72
Atividade em aula
Implementar uma TAD para pilha em lista encadeada com as seguintes operações :
1. Criar uma pilha vazia2. Empilhamento3. Desempilhamento4. Imprime a pilha
73
Pilha em C (arquivo pilha.h) – Ex2
typedef struct {int matricula;char nome[20];
} t_pilha;
void empilha(t_pilha aluno);t_pilha desempilha();t_pilha noTopo();int cheia();int vazia();
74
MC-1424 Algoritmos e Estruturas de Dados I - 2° trimestre de 2009
Pilha em C (arquivo pilha.c) –Ex2#include "pilha.h“
#define TAMMAX 3
#define VAZIA -1
int topo = VAZIA;
t_pilha pilha[TAMMAX];
void empilha(t_pilha aluno){
pilha[++topo] = aluno;
}
t_pilha desempilha() {
return pilha[topo--];
}
t_pilha noTopo() { return pilha[topo];}
int cheia() { return topo+1 == TAMMAX;
}
int vazia() { return topo == VAZIA;
}75
Recommended