Estruturas de Dados

Tipos estruturados (revisão de C)

#include <stdio.h>

struct ponto { Definição da struct

float x;
float y;
};

int main(void) {
struct ponto p;
printf("Digite as coordenadas do ponto(x y): ");
scanf("%f %f", &p.x, &p.y);
printf("Ponto=(%.2f,%.2f)\n", p.x, p.y); Operador de acesso “ponto”
return 0;
}

void imprime(struct ponto p) { p é passado por valor: não é possível alterar a struct
printf("Ponto=(%.2f,%.2f)\n", p.x, p.y); original e pode ser ineficiente (uma cópia da struct é
colocada na pilha)
}

void imprime(struct ponto* pp) { p é passado por referência (ponteiro para struct ponto)
printf("Ponto=(%.2f,%.2f)\n", pp->x, pp->y); Operador de acesso “seta” é equivalente a (*pp).x
}
Alocação dinâmica de estruturas

struct ponto* p; • aloca-se dinamicamente uma estrutura e armazena-se o endereço da

área alocada em p
p = (struct ponto*)malloc(sizeof(struct ponto)); • sizeof retorna o espaço necessário para armazenar uma estrutura
• malloc retorna o endereço do espaço alocado
p->x = 12.0;

Definição de “novos” tipos

typedef unsigned char UChar; typedef struct ponto Ponto;
typedef int * PInt; struct ponto {
typedef float Vetor[4]; float x;
Vetor v; float y;
v[0] = 3; };

typedef struct ponto {

float x;
float y;
} Ponto;
Vetores de ponteiros para estruturas

• Útil quando temos que tratar um conjunto de elementos com muitas informações
typedef struct aluno Aluno;
struct aluno {
int mat;
char nome[81]; O tipo Aluno definido ocupa pelo menos 227 (=4+81+121+21) bytes.
char end[121];
char tel[21];
}; Desperdício significativo de memória caso um número de alunos bem
... inferior ao máximo estimado seja armazenado.
# define MAX 100
...
Aluno tab[MAX];
...
tab[i].mat = 9912222
...
Aluno* tab[MAX];
Vetor de ponteiros: cada elemento do vetor ocupa apenas o espaço
necessário para armazenar um ponteiro.

Quando precisar alocar os dados de um aluno numa determinada posição do

vetor, aloca-se dinamicamente a estrutura Aluno e guarda-se seu endereço
no vetor de ponteiros.
 Listas simplesmente encadeadas
• Para cada novo elemento na estrutura, aloca-se um espaço de
memória para armazená-lo
• O espaço total de memória gasto pela estrutura é proporcional ao número
de elementos armazenados
• No entanto, não é possível garantir que os elementos armazenados na
lista ocuparão um espaço de memória contíguo; portanto, não temos
acesso direto aos elementos da lista
• Para que seja possível acessar todos os elementos da lista, deve-se typedef struct lista Lista;
guardar o encadeamento dos elementos armazenando um ponteiro para typedef struct listano ListaNo;
o próximo nó da lista
struct lista {
ListaNo *prim;
};

struct listano {
int info;
ListaNo *prox;
• O último nó da lista armazena, como próximo nó, um ponteiro inválido, };
com valor NULL , sinalizando que não existe um próximo nó
• A lista em si é ser representada por um ponteiro para o primeiro nó
Listas simplesmente encadeadas

• Função de criação: cria lista vazia

Lista *lst_cria(void) {
Lista *l = (Lista *)malloc(sizeof(Lista));
l->prim = NULL;
return l;
}

• Função de inserção (no início)

void lst_insere(Lista *l, int v) {

ListaNo *novo = (ListaNo *)malloc(sizeof(ListaNo));
novo->info = v;
novo->prox = l->prim;
l->prim = novo;
}
Listas simplesmente encadeadas

• Função que percorre os elementos da lista

void lst_imprime(Lista *l) {
for (ListaNo *p = l->prim; p != NULL; p = p->prox)
printf("info = %d\n", p->info);
}

• Função de pertencimento de um nó à lista (retorna 1 se o valor aparecer na lista, 0 caso contrário)

int pertence(Lista *l, int v) {
for (ListaNo *p = l->prim; p != NULL; p = p->prox){
if (p->info == v)
return 1;
}
return 0;
}