Baixe Técnicas de Programação Parte4 e outras Notas de estudo em PDF para Informática, somente na Docsity!
void __fastcall TForm1::PaintBox1Paint(TObject *Sender) { TPaintBox *pCor = (TPaintBox *)Sender; int x; for (x=0; x <= pos;x++) { pCor->Canvas->Pen->Color = (Graphics::TColor) random(65535); PaintBox1->Canvas->MoveTo(coord[x].X1,coord[x].Y1); PaintBox1->Canvas->LineTo(coord[x].X2,coord[x].Y2); } }
8.9 Exercícios
1- Modifique o programa acima para apresentar no formulário a posição do mouse quando
movimentado dentro do PaintBox.
Resp: Testar o evento MouseMove do PaintBox
2- Modifique o exemplo acima, adicionando a possibilidade de desenhar retângulos e elipse (
botão para retângulo e 1 botão para Elipse).
Resp: Use os comandos Rectangle() e Ellipse()
3- Modifique o exemplo acima, adicionando a possibilidade de inserir pontos de acordo com
coordenadas definidas pelos usuários. Exemplo:
PaintBox1->Canvas->Pixels[X1][Y1] = clRed;
9. LISTAS LINEARES
9.1. Fila
9.1.1. Definição
Uma FILA é uma lista linear de dados acessada na ordem em que o primeiro elemento que
entra na lista é o primeiro a ser retirado. Também é chamada de lista FIFO (First In, First
Out). Um exemplo comum, é uma fila de branco. Elementos podem ser adicionados às filas e
retirados. A cada adição, consequentemente, aumenta a fila, e a cada saída, diminui-se a fila;
então uma fila pode ficar com comprimento 0.
9.1.2. Objetivo
As filas são muito usadas em programação. Servem principalmente para simulações e
distribuição de eventos como diagramas PERT, e bufferização de Entrada e Saída (Fila de
impressão).
9.1.3. Exemplo
Supondo duas funções Insere() e Retira() , que inserem e retiram respectivamente elementos
da fila, temos:
Ação Conteúdo da Fila
Insere(A)
Insere(B)
Insere(C)
Retira( )
Insere(D)
Retira( )
Retira( )
Retira( )
[A]
[A B]
[A B C]
[B C]
[B C D]
[C D]
[D]
[]
Exemplo de função em C que executa os comandos de inserção apresentadas no item 9.1.3,
acima:
#define MAX 20 char *p[MAX];// vetor de ponteiros int prox=0; // próximo elemento livre da fila int prim=0; // primeiro elemento da fila // insere elementos na fila void Insere( char *q) { if (prox==MAX) { Application->MessageBox("Lista Cheia","Mensagem",MB_OK); return ; //lista cheia } // se Insere recebe 'A' p[prox] = q; // p[0] aponta para o endereço de 'A' "&q" prox++; // próxima posição vazia da lista. }
Exemplo de função em C que executa os comandos de remoção apresentadas no item 9.1.3,
acima:
// retira elementos da fila, esta função retorna um ponteiro char *retira() { if (prim==prox) { Application->MessageBox("Lista Vazia","Mensagem",MB_OK); return NULL; } prim++; // início da fila para o segundo elemento return p[prim-1]; // retorna o elemento retirado da fila }
9.2. Fila Circular
Quando o limite do tamanho da fila é atingido, é possível retornar ambos os índices ( prim e
prox ) para o início do vetor utilizado. Assim pode-se ter um aproveitamento maior da lista.
A B C D E F G H I J
Baseado no exemplo anterior, a fila estará cheia se:
a) prox está uma posição anterior a prim , ou se;
b) prox estiver no final e prim no início da lista.
Condição de Fila Cheia a)
A B C D E F G H I J
Condição de Fila Cheia b)
A B C D E F G H I J
prim
prox
prim
prox
prim
prox
9.3. Pilha
9.3.1. Definição
Uma PILHA é o inverso de uma FILA. Baseia-se no princípio LIFO (Last IN, First OUT ), ou
seja o último elemento adicionado é o primeiro a ser retirado. Uma pilha de pratos é um
exemplo. Pilhas são muito usadas em compiladores. As duas operações para armazenar e
retirar elementos da pilha são tradicionalmente denominadas push e pop.
Ação Conteúdo da Fila
Push(A)
Push(B)
Push(C)
Pop( )
Push(D)
Pop( )
Pop( )
Pop( )
[ A ]
[ B A ]
[ C B A ]
[ B A ]
[ D B A]
[ B A ]
[ A ]
[ ]
9.3.2. Exemplo
#define MAX 20 int *p; int *topo; int *tama;
void push( int i) { if (p > tama) { Application->MessageBox("Pilha Cheia","Mensagem",MB_OK); return ; //pilha cheia }
*p = i; // falta alocar memoria para p p++; // proxima posicao da pilha }
int pop( void ) { p--; if(p < topo) { Application->MessageBox("Pilha Vazia","Mensagem",MB_OK); return 0; //pilha vazia } return *p; }
/** Antes que estas funções possam ser usadas, uma região de memória livre deve ser alocada com MALLOC(). O endereço de início dessa região deve ser atribuída a topo , e o endereço final a tama .* */
void main( void ) { // obtém memória para a pilha p = (int *) malloc(MAX * sizeof(int)); if (!p) { Application->MessageBox("Falha de Alocação","",MB_OK); exit(1) ; } topo = p; // topo da pilha tama = p + MAX -1; // tamanho máximo da pilha
9.4. Exercícios
1- Desenvolva um programa em C para simular as operações de inserção e retirada de
elementos de uma fila. A partir do formulário abaixo, a cada clique do botão "Fila", um
9.6. Exemplo
Criar uma lista encadeada com os seguintes elementos:
Elemento A Elemento B Elemento C
Nome: Fulano
Idade: 30
Nome: Fulano
Idade: 31
Nome: Fulano
Idade: 32
//Declarado como global typedef struct aluno { char nome[50]; int idade; struct aluno *prox; }
aluno *inicio, *pt_aux; // associado a um botão: { pt_aux = (aluno *) malloc(sizeof(aluno)); strcpy(pt_aux->nome,"Fulano1"); pt_aux->idade = 30; pt_aux->prox = NULL; inicio = pt_aux; pt_aux = (aluno *) malloc(sizeof(aluno)); strcpy(pt_aux->nome,"Fulano2"); pt_aux->idade = 31; pt_aux->prox = inicio; inicio = pt_aux; pt_aux = (aluno *) malloc(sizeof(aluno)); strcpy(pt_aux->nome,"Fulano3"); pt_aux->idade = 32; pt_aux->prox = inicio; inicio = pt_aux; }
9.7. Exercício
1- Altere o exemplo acima para uma função que execute a inserção de elementos em uma lista
encadeada.
9.8. Exemplo
Duas coordenadas de tela X e Y, podem estar definidas numa estrutura. Se quisermos guardar
uma sequência de pontos, podemos criar uma lista encadeada para armazená-los, assim que
forem gerados. Uma estrutura para isto poderia ser da seguinte forma:
struct pontos { int X; int Y; struct pontos *prox; };
Os ponteiros de uma lista encadeada apontam nós que são semelhantes em termos de tipos de
dados. Assim, os ponteiros são declarados como sendo elementos que apontam para o tipo da
estrutura que define o nó.
Neste exemplo temos o ponteiro *prox, que aponta elementos do tipo struct pontos.
Também é necessário conhecer o início da lista. Pode-se definir um ponteiro para isto
também, como:
struct pontos *ini; // é um ponteiro para estrutura pontos
Operação de Remoção:
A codificação em C para uma operação de remoção pode ser:
int remove( struct pontos *elemento) { struct pontos *ant; if (elemento == NULL) return 0; for (ant = ini; ant != NULL ; ant = ant->prox) { if (ant->prox == elemento) { ant->prox = elemento->prox; free (( struct pontos *)); break ; } } return 1; }
9.10. Exemplo
#include <stdio.h> #define ALOCA (struct aluno *) malloc(sizeof(struct aluno)) struct aluno { char nome[20]; int idade; struct aluno *prox; };
struct aluno *nova(void) { struct aluno *x; x = ALOCA; x->prox = 0; return (x); } //---------------------------------------------------- struct aluno *insere(struct aluno pt) { if (pt->prox == NULL) { strcpy(pt->nome,Form1->Edit1->Text.c_str()); pt->idade = atoi(Form1->Edit2->Text.c_str()); pt->prox = nova(); } else insere(pt->prox); return (pt); } //---------------------------------------------------- __fastcall TForm1::TForm1(TComponent Owner) : TForm(Owner) { inicio = ALOCA; proximo = ALOCA; } //---------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { proximo = insere(proximo); }
9.13. Exemplo
#define ALOCA (struct aluno *) malloc(sizeof(struct aluno))
struct aluno { char nome[20]; int idade; struct aluno *prox; struct aluno *ant; }; struct aluno *registro; struct aluno *inicio; struct aluno *ultimo; struct aluno *pos; //------------------------------------------------------------------------- struct aluno *nova(void) { struct aluno x; x = ALOCA; x->ant = registro; x->prox = 0; ultimo = x; return (x); } //------------------------------------------------------------------------- struct aluno insere(struct aluno *pt) { if (pt->prox == NULL) {
strcpy(pt->nome,Form1->Edit1->Text.c_str()); pt->idade = atoi(Form1->Edit2->Text.c_str()); pt->prox = nova(); } else { insere(pt->prox); } return (pt->prox); } //------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { inicio = registro = ALOCA; } //------------------------------------------------------------------------- -- void __fastcall TForm1::bInsereClick(TObject *Sender) { registro = insere(registro); Edit1->Text = ""; Edit2->Text = ""; } //------------------------------------------------------------------------- void __fastcall TForm1::bApagaClick(TObject *Sender) { free(registro); Close(); } //------------------------------------------------------------------------- void __fastcall TForm1::bAnteriorClick(TObject *Sender) { pos = (registro->ant != NULL)? registro->ant:ultimo; Edit1->Text = pos->nome; Edit2->Text = pos->idade; registro = pos; } //-------------------------------------------------------------------------
Anexo I
10. RECURSIVIDADE
10.1. INTRODUÇÃO
Na linguagem C, funções podem chamar a si mesmas. A função é dita recursiva se um
comando no corpo da função a chama novamente. A cada chamada, obtém-se um novo
conjunto de todas as variáveis usadas na função, independente do conjunto anterior.
10.2. EXEMPLO
Pode-se por exemplo fazer um programa para calcular o fatorial de um número de duas
formas. O exemplo 1 apresenta uma solução sem o uso de recursividade e o exemplo 2 usa o
conceito de recursão.
10. 2.1. Exemplo 1 - Função não recursiva.
int fatorial ( int n)
int t, resp;
resp = 1;
for (t=1; t <= n; t++) resp = resp * t;
return (resp);
Neste exemplo é passado o valor a ser calculado através da variável "n", à função fatorial().
Esta função executa um loop de "t" vezes, onde a variável "resp" é multiplicada pelas
iterações de "t".
Anexo I
10.2.2. Exemplo 2 - Função recursiva.
int fat_rec ( int n)
int resp;
if (n <= 1) return (1);
resp = fat_rec(n-1) * n; // chamada recursiva
return (resp);
Neste exemplo, quando fat_rec() é chamada com argumento menor ou igual a 1, ela retorna o
valor 1 como resposta, caso contrário, ela devolve o produto de fat_rec(n-1)*n. Para avaliar
esta expressão, fat_rec() é chamada com n-1; isso acontece até que n se iguale a 1 e as
chamadas à função começam a retornar.
O uso de funções recursivas permite criar versões mais simples de vários algoritmos.
10.3. Exercícios
1- Crie um formulário no C builder para calcular o fatorial de um número, com e sem
recursividade. Use as funções dos exemplos 2.1 e 2.2. Verifique passo a passo à execução do
programa e explique o funcionamento.
2- Faça um programa no C builder para calcular x^y ( x elevado a y) usando uma função
recursiva.
