Estruturas de Dados II

0-Revisão de Ponteiros, Vetores e Matrizes

Lidio Mauro Lima de Campos

lidio@ufpa.br

Universidade Federal do Pará - UFPA

Referências
 Waldemar Celes, Renato Cerqueira, José
Lucas Rangel, Introdução a Estruturas de
Dados, Editora Campus (2004)
 Kernigan, B.W. Ritchie, D.M. A Linguagem
de Programação C. Campus.
Variáveis do Tipo Ponteiro
 A linguagem C permite o armazenamento
e a manipulação de valores de endereços
de memória.
 Para cada tipo existente, existe um tipo
ponteiro correspondente.
Variável Ponteiro
float a float *a
char c char *c
int a int *a
Variáveis do Tipo Ponteiro
 O operador & (endereço de) aplicado a
variáveis retorna o endereço da posição de
memória reservada a variável.
 O operador * (conteúdo de) aplicado a
variáveis do tipo ponteiro, retorna o
conteúdo do endereço de memória
armazenado pela variável ponteiro.
Variáveis do Tipo Ponteiro
Exemplo de Função
#include<stdio.h>
void somaprod(int x, int y, int *s, int *p)
{
*s = x+y;
*p = x*y;
}
int main (void)
{
int s, p;
somaprod(3,5,&s,&p);
printf(''soma = %d, prod = %d'',s,p);
return 0;
}
Exemplo de Função
#include<stdio.h>
void troca(int *px, int *py)
{
int temp = *px;
*px = *py;
*py = temp;
}
int main (void)
{
int a=5, b =7;
troca(&a,&b);
printf(''a=%d, b=%d'',a,b);
return 0;
}
Pilha de Execução
Resumo de Ponteiros
 Vetor
 Estrutura de dados definindo um conjunto
Enumerável.
 int v[]={2,3,4};
 int v[3] = {2, 3, 4};
 v[0] = 2 ou *v =2
 v[1] = 3 ou *(v+1) =3
 v[2] = 4 ou *(v+2) =4
 De forma geral,
◦ v[i] equivale a *(v+i)
◦ &v[i] equivale a (v+i)
 Somatório de um Vetor
#include<stdio.h>
float somatorio(int m, float v[])
{
int i; float s =0.0F;
for(i=0;i<m;i++)
s += v[i];
return s;
}

int main (void)

{
float v[] = {2.0, 3.0, 4.0};
float s = somatorio(3,v);
printf(''somatorio=%.1f,media=%.1f'',s,s/3);
return 0;
}
 Alocação Dinâmica
 Uso da memória:
◦ Uso de variáveis globais (e estáticas):
 Espaço reservado para uma variável global existe
enquanto o programa estiver sendo executado.
◦ Uso de variáveis locais:
 Espaço existe apenas enquanto a função que declarou a
variável está sendo executada.
 Liberado para outros usos quando a execução da função
termina.
◦ Variáveis globais ou locais podem ser simples ou vetores:
 para vetores é necessário informar o número máximo de
elementos pois o compilador precisa calcular o espaço a
ser reservado.
 Alocação Dinâmica
 Uso da memória:
– Alocação dinâmica:
 Espaço de memória é requisitada em tempo de
execução.
 Espaço permanece reservado até que seja
explicitamente liberado
◦ depois de liberado, espaço estará disponibilizado para
outros usos e não pode mais ser acessado.
◦ espaço alocado e não liberado explicitamente, será
automaticamente liberado quando ao final da execução.
Alocação Dinâmica
 Alocação Dinâmica
 Quando o número de elementos não é
conhecido em tempo de compilação;
 A função sizeof retorna o número de
bytes de um tipo;
 A função malloc recebe como parâmetro o
número de bytes a serem alocados
int *v = (int*)malloc(3*sizeof(int));
 v[0]=2;
 v[1]=3;
 v[2]=4;
 Somatório de um Vetor
#include<stdio.h>
#include<stdlib.h>
float somatorio(int m, float v[]){ ... }
int main (void)
{
int n; int i; float *v; float s;
scanf(''%d'',&n);
v = (float*) malloc(n*sizeof(float));
for(i=0; i<n; i++)
scanf(''%f'',&v[i]);
s = somatorio(n,v);
printf(''somatorio=%.1f,media=%.1f'',s,s/n);
return 0;
}
 Alocação Dinâmica
 A função malloc pode retornar NULL, caso não
tenha espaço suficiente

if (v==NULL)
{
printf(''Memoria Insuficiente'');
exit(1);
}

 O espaço alocado deve ser liberado

free(v);
Vetor :Passagem por referência
Vetor :Passagem por referência
Vetor :Passagem por referência
 Exercicios
 1) Faça um programa que leia 10
números inteiros, coloque-os num vetor e
mostre-os em ordem inversa.
 2)Implemente uma Pesquisa sequencial
realizada em um vetor, em ordem direta e
inversa.
 3)Faça um programa que leia uma lista de
100 números INTEIROS E MOSTRE os
números impares.
 Matrizes
 Vetor Bidimensional (Matriz)
float m[4][3] = {{5.0,10.0,15.0},
{20.0,25.0,30.0},
{35.0,40.0,45.0},
{50.0,55.0,60.0}};

m[0][0]=5.0;
m[2][1]=40.0;
Passagem de Matrizes para
Funções
 Somatório de uma Matriz

float somatorio(int m, float v[][3])

{
int i, j; float md =0.0F;
for(i=0;i<m;i++)
for(j=0;j<3;j++)
md += v[i][j];
return md;
}
Alocação Dinâmica de Matrizes
Alocação Dinâmica de Matrizes
 Representação por Vetor Simples

 1)ALOCAÇÃO
◦ float* mat;
◦ mat=(float*)malloc(n*m*sizeof(float));
 2)PREENCHIMENTO
◦ for(i=0;i<m;i++)
 for(j=0;j<n;j++)
◦ scanf("%f",&mat[i*n+j]);
 3)LIBERAR ESPAÇO DE MEMÓRIA
free(mat);

Ver exemplovetorsimples.cpp
Alocação Dinâmica de Matrizes
 Representação por Vetor de Ponteiros
Alocação Dinâmica de Matrizes
 Representação por Vetor de Ponteiros
 1)ALOCAÇÃO
◦ float** mat;
◦ mat=(float**)malloc(m*sizeof(float*));
//vetor de ponteiros

for(i=0;i<n;i++)
{ mat[i]=(float*)malloc(n*sizeof(float));}
//cada uma das linhas da matriz

 2)PREENCHIMENTO
◦ for(i=0;i<m;i++)
◦ for(j=0;j<n;j++)
◦ scanf("%f",&mat[i][j]);
 3)LIBERAR ESPAÇO DE MEMÓRIA
◦ for(i=0;i<m;i++)
◦ free(mat[i]);
◦ free(mat); Ver exemplovetorponteiros.cpp
Alocação Dinâmica de Matrizes
 Operações com Matrizes
◦ 1)Matriz Transposta Representação
por Vetor Simples.
◦ 2)Matriz Transposta Representação
por Vetor de Ponteiros.
 Tipos Estruturados
 Normalmente trabalhamos com tipos básicos
disponibilizados pela linguagem C: char, int, float, double.
 Desenvolvimento de Programas mais complexos, precisa-se
trabalhar de uma maneira mais abstrata para representar
dados.
◦ Ex:Dados Compostos por diversas informações.
 Ponto no espaço bidimensional
 Abstração : Ponto é representado pelas coordenadas
(x,y);
◦ C oferece mecanismos para agrupar as duas
coordenadas (x,y) no mesmo contexto, para que seja
possível tratar o ponto como um único objeto.
 Tipos Estruturados
 Manipulação de dados compostos ou
estruturados.
 Exemplo 1: Ponto no espaço
Bidimensional.

 Representado por duas coordenadas

(x,y).
 Mas tratado como um único objeto
ou tipo.
 Tipos Estruturados
 Manipulação de dados compostos ou
estruturados.
 Exemplo 2: Dados Associado a um aluno.

 Aluno representado pelo seu nome,

número de matrícula, endereço.
 Estruturados em um único objeto ou (tipo)
Tipos Estruturados - Definição
 Um tipo estruturado é definido como segue:
struct <nome_var>
{
<lista_tipos_simples>
};
 Podemos agrupar os dados de um ponto (x,y)
da seguinte forma:
struct ponto
{
float x;
float y;
};
Tipos Estruturados - Definição
 A definição de uma variável é de forma
usual.
struct ponto p;

 Para acessar os campos, usamos o

operador ''ponto'' (.).
 p.x = 10.0;
 p.y = 5.0;
Tipos Estruturados - Definição
 A definição de uma variável é de forma
usual.
struct ponto p;

 Para acessar os campos, usamos o

operador ''ponto'' (.).
 p.x = 10.0;
 p.y = 5.0;
Tipos Estruturados - Exemplo

◦ Sem mecanismo para agrupar as duas componentes

teríamos:
 float x;
 float y;
◦ Mecanismo para agrupamento de dados:
struct ponto
{ float x;
float y;
};
Após a definição da estrutura ponto a mesma passa a
ser um tipo:
 struct ponto p;
Tipos Estruturados - Exemplo
 acesso aos dados:
 struct_var.campo
Ex:
 p.x = 10; /*atribuição */
 p.y = 15;
 if (p.x >= p.x) &&(p.y >= p.y) ...

 Ver exemplo:
 (struct1.c) e (struct2.c)
 Passagem de Estruturas para Funções –
Passagem por valor
 A passagem de variáveis do tipo estrutura
para funções funciona de maneira análoga
à de variáveis simples .
void imprime(struct ponto p)
{
printf("Ponto(%.2f,%.2f)\n:",p.x,p.y);
}
 O valor da variável é copiado para a pilha
de execução.
 Inicialização de Estruturas

 Inicialização de uma Estrutura

struct ponto p = { 220, 110 };
 Atribuição entre estruturas do mesmo
tipo:
struct ponto p1 = { 220, 110 };
struct ponto p2;
 p2 = p1; /* p2.x = p1.x e p2.x = p1.y */
 Os campos correspondentes das
estruturas são automaticamente copiados
do destino para a fonte.
 Exercícios

 1)Representar um circulo por um struct,

funções imprime, desloca.
◦ struct3.c
 2)Representar um retangulo por um struct,
funções imprime, calcula_diagonal,
calcula_area.
◦ Considerar que retangulo é definido por um
ponto inicio (canto inferior esquerdo) e por
um ponto fim (canto superior direito).
◦ struct4.c
 Exercícios

 1)Representar um circulo por um struct,

funções imprime, desloca.
◦ struct3.c
 2)Representar um retangulo por um struct,
funções imprime, calcula_diagonal,
calcula_area.
◦ Considerar que retangulo é definido por um
ponto inicio (canto inferior esquerdo) e por
um ponto fim (canto superior direito).
◦ struct4.c
 Ponteiros para Estruturas
 Acesso ao valor de um campo x de uma variável estrutura
p, p.x ;
 Acesso ao valor de um campo x de uma variável ponteiro
pp , pp->x;
 Acesso ao endereço de um campo x de uma variável
ponteiro pp, &pp->x;

 Ex: struct ponto *pp;

(*pp).x=12.0;
ou
pp->x=12.0;
 Passagem de Estruturas para funções – por
referência.
 Apenas o ponteiro da estrutura é passado.
void imprime(struct ponto *pp)
{
printf("o ponto fornecido foi:(%.2f,%.2f)\n",pp-
>x,pp->y);
}
void captura(struct ponto* pp)
{ printf("Digite as coordenadas do pontos");
scanf("%f",&pp->x);
scanf("%f",&pp->y);
}
 Passagem de Estruturas para funções – por
referência.
 Apenas o ponteiro da estrutura é passado.
void imprime(struct ponto *pp)
{
printf("o ponto fornecido foi:(%.2f,%.2f)\n",pp-
>x,pp->y);
}
void captura(struct ponto* pp)
{ printf("Digite as coordenadas do pontos");
scanf("%f",&pp->x);
scanf("%f",&pp->y);
}
 Passagem de Estruturas para funções – por
referência.
#include<stdio.h>
#include<conio.h>
struct ponto
{float x; float y;};

void imprime(struct ponto *pp)

{ printf("o ponto fornecido foi:(%.2f,%.2f)\n",pp->x,pp-
>y);}

int main(void)
{struct ponto p;
printf("Digite as coordenadas do pontos");
scanf("%f",&p.x); scanf("%f",&p.y);
imprime(&p); getche();
return 0;
}
 Passagem de Estruturas para funções – por
referência.
#include<stdio.h> #include<conio.h>
struct ponto
{ float x; float y; };

void imprime(struct ponto *pp)

{ printf("o ponto fornecdido foi:(%.2f,%.2f)\n",pp->x,pp->y); }

void captura(struct ponto* pp)

{ printf("Digite as coordenadas do pontos");
scanf("%f",&pp->x); scanf("%f",&pp->y);}

int main(void)
{ struct ponto p;
captura(&p);
imprime(&p);
getche(); return 0;
}
 Alocação Dinâmica de Estruturas

 Tamanho do espaço de memória alocado é dado

pelo operador sizeof aplicado sobre o tipo
estrutura.
 Função malloc retorna o endereço do espaço
alocado, que é convertido para o tipo ponteiro da
estrutura.
struct ponto* p;
p=(struct ponto*)malloc(sizeof(struct ponto));
if(p==NULL)
{ printf("memoria insuficiente");
exit(1);}
free(p);
 Alocação Dinâmica de Estruturas

int main(void)
{
struct ponto* p;
p=(struct ponto*)malloc(sizeof(struct ponto));
if(p==NULL)
{
printf("memória insuficiente");
exit(1);
}
captura(p);
imprime(p);
free(p);
getche();
return 0;
}
 Alocação Dinâmica de Estruturas
#include<stdlib.h>
#include<conio.h>
struct ponto
{
float x;
float y;
};

void imprime(struct ponto *pp)

{
printf("o ponto fornecdido foi:(%.2f,%.2f)\n",pp->x,pp->y);
}

void captura(struct ponto* pp)

{
printf("Digite as coordenadas do pontos");
scanf("%f",&pp->x);
scanf("%f",&pp->y);
}