Professional Documents
Culture Documents
Vetores ou arrays
Vetores, ou arrays, são estruturas de dados lineares e estáticas, isto é, são compostas por
um número fixo (finito) de elementos de um determinado tipo de dados.
O espaço de memória utilizado é alocado em tempo de compilação (declaração das
variáveis), ou seja, quando o programa começa a ser executado, as variáveis do tipo vetor
já estão alocadas na memória com o número total de elementos.
O tempo de acesso aos elementos de um vetor é muito rápido, sendo considerado
constante: os elementos são acessados pelo seu índice no vetor.
Porém, a remoção de elementos pode ser custosa se não for desejável que haja espaços
"vazios" no meio do vetor, pois nesse caso é necessário "arrastar" de uma posição todos
os elementos depois do elemento removido.
Essa é uma estrutura muito recomendada para casos em que os dados armazenados não
mudarão, ou pouco mudarão, através do tempo.
Lista
A Lista é uma estrutura de dados linear, composta por uma sequência de nós ou nodos.
Existem duas formas de representar as listas:
- Alocação sequencial: os nós ocupam posições sequenciais contíguas.
- Alocação dinâmica (encadeada): os nós (celulas) apontam para o próximo
elemento da lista.
Diferentemente dos vetores, na alocação dinâmica a reserva de memória para cada célula
(nó) ocorre em tempo de execução do programa. Neste caso, a quantidade máxima de nós
em uma lista será determinada pelo tamanho de memória disponível no computador.
Para trabalhar com uma lista dinâmica (ligada), devemos guardar o primeiro elemento da
lista.
Lista simplesmente encadeada (LSE): cada nó da lista ponta para o próximo nó.
A LSE só pode ser percorrida em um único sentido
Lista Circular: O primeiro nó aponta para o último e o último aponta para o primeiro.
São baseadas no princípio LIFO (last in, first out) ou UEPS (Último a entrar, primeiro a sair)
onde os dados que foram inseridos por último na pilha serão os primeiros a serem
removidos.
Exemplo:
13
19
14
10
Pop x
Pop y
Pop z
Push y 14
Push x 13
Push z 19
10 Resposta:
4
3
2
1
A B C
Push(B,pop(A))
Push(C,pop(A))
Push(B,pop(A))
Push(C,pop(A))
Push(A,pop(B))
Push(C,pop(B))
Push(C,pop(A))
2
4
1
3
A B C
Resposta:
As filas são estruturas baseadas no princípio FIFO (first in, first out) ou PEPS (Primeiro a
entrar, primeiro a Sair) em que os elementos que foram inseridos no início são os primeiros
a serem removidos.
Uma fila possui duas funções básicas: ENQUEUE (incluir - INC), que adiciona um
elemento ao final da fila, e DEQUEUE (retirar - DEL), que remove o elemento no início da
fila.
A) FILO
B) LIFO
C) UEPS
D) LILO
E) FIFO
Resposta: E
A) LIFO
B) FILO
C) PEPS
D) LILO
E) FIFO
Resposta: A
inicio
Y F C
INC “X”
INC “T”
DEL
DEL
INC “R”
INC “J” Resposta:
DEL C–X–T–R-J
Deque de entrada restrita: A remoção poder ser feita por qualquer extremidade, porém as
inclusões podem ser feitas apenas por uma.
Deque de saída restrita: A inclusão poder ser feita por qualquer extremidade, porém as
remoções podem ser feitas apenas por uma.
A grande diferença da lista para as outras estruturas de dados, é que as listas não
possuem critério de inclusão e remoção de dados.
Uma lista encadeada tem necessariamente uma variável ponteiro apontando para o seu
primeiro elemento. Essa variável será utilizada sempre, mesmo que a lista esteja vazia, e
deverá apontar sempre para o início da lista (primeiro elemento). Caso esta primeira
variável não seja atualizada corretamente (no caso da inclusão de um elemento na
primeira posição), a lista poderá se perder na memória e não ser mais acessível.
Uma vez que o primeiro elemento será uma célula, e cada célula é uma estrutura, então a
variável que apontará para o início da lista será um ponteiro de estrutura.
inicio = NULL;
Para uma lista vazia (sem células), a variável inicio possui valor NULL:
Temos então:
e precisamos atualizar os ponteiros para que a lista receba seu primeiro elemento. Sendo
assim:
1) aux->proximaCelula = NULL; // atribui NULL ao campo proximacelula da célula
apontada por aux
2) inicio = aux; // copia o endereco de aux em inicio
2
Para inserir dados nesta primeira célula, podemos utilizar o ponteiro aux, que permanece
apontando para a célula.
aux->dados = 10; /*atribui o valor 10 ao campo dados da célula pontada por aux
O programa a seguir cria uma lista com três nós, conforme exibida a abaixo
inicio
matricula proximo
11 2 3
Noções da L inguagem C 7 pá
#include <stdio.h>
#include <stdlib.h>
main( )
{ typedef struct no
{int matricula;
stuct no *proximo;
} tipoNo;
Noções da L inguagem C 8 pá
O programa abaixo cria uma lista dinâmica (FILA) com 5 nós, contendo as matrículas:
1, 2, 3, 4, e 5, respectivamente.
#include "stdio.h"
#include <stdlib.h>
main()
{ typedef struct no
{int matricula;
struct no *proximo;
}tipoNo;
}
/* exibe a lista */
atual = inicio;
while (atual != NULL)
{ printf("\n matricula = %d ",atual->matricula);
atual=atual->proximo;
}
getch();
}
Inicio
matricula
prox
11 2 3 4 5
Noções da L inguagem C 9 pá
O programa abaixo cria uma lista dinâmica (tipo Pilha) com 3 nós, contendo as matrículas:
1, 2, e 3.
topo
matriculaaprox
#include <stdio.h>
3 2 1
main()
{
typedef struct no
{int matricula;
struct no *proximo;
}tipoNo;
clrscr();
/* inclui primeiro registro na pilha */
novo = malloc(sizeof(tipoNo));
novo->matricula = 1;
novo->proximo = NULL;
topo = novo;
#include "stdio.h"
main()
{
typedef struct no
{int matricula;
struct no *proximo;
}tipoNo;
clrscr();
topo
matricula proximo
15 4 3 2 1
Para percorrer uma lista (fila ou pilha) temos que utilizar uma variável auxiliar (ponteiro
auxiliar).
Inicialmente, aux deverá apontar para o início da fila (ou para o topo, no caso das pilhas).
Depois, aux receberá o endereço contido no campo proximo, ou seja, receberá o
endereço da próxima célula (próximo nó).
Enquanto aux for diferente de NULL, repete-se o processo acima.
Observe o trecho de programa a seguir que exibirá todos os nós da lista.
aux = inicio;
while (aux != NULL)
{ printf("\n matricula = %d ",aux->matricula);
aux = aux->proximo;
}
getchar();
}
Inicio
matricula proximo
11 2 3 4 5
O último nó da lista não apontava para nenhum outro, agora, este deverá apontar para o
novo nó.
Início 10 27
valor Próximo valor Proximo
- se a lista não é vazia, percorrer a lista até a última célula (aux apontará para o último nó)
- alocar memória para o novo nó (malloc)
- atribuir dados aos campos de dados
- atribuir NULL ao campo ponteiro da nova célula incluída
- atribuir ao campo ponteiro da última célula o endereço da nova célula
if (inicio != NULL)
{ aux = inicio;
while(aux->proximo != NULL)
aux = aux->proximo;
novo = malloc(sizeof(tipoNo))
novo->valor = 55;
novo->proximo = NULL;
aux->proximo = novo;
}
Início
10 27 55
valor Proximo valor Proximo Valor Proximo
Início 2 7 3
Dado Prox Dado Prox Dado Prox
Dado prox
17 3
Observe a lista:
Início 2 7 3
Dado Prox Dado Prox Dado Prox
Início 2 7 3
Dado Prox Dado Prox Dado Prox
As listas duplamente encadeadas são aquelas em que cada nó possui não só o endereço
do nó anterior mas também o endereço do próximo nó. Observe o gráfico e a declaração
abaixo:
typedef struct no
{ int matricula;
char nome[30];
struct no *proximo;
} tipoNo;
tipoNo *inicio;
A)
B) A) Pode ser a estrutura de uma fila estática
C) B) Pode ser a estrutura de um registro de vetor
D) C) Pode ser a estrutura de uma lista duplamente encadeada
E) D) Pode ser a estrutura de uma lista encadeada dinâmica
F) E) Pode ser a estrutura de uma lista estática
typedef struct no
{ int matricula;
char nome[30];
int proximo;
} tipoNo;
tipoNo x[50];
G) A) Pode ser a estrutura de uma lista simplesmente encadeada estática
H) B) Pode ser a estrutura de um PILHA dinâmica
I) C) Pode ser a estrutura de uma lista duplamente encadeada
J) D) Pode ser a estrutura de uma lista encadeada dinâmica
K) E) Pode ser a estrutura de uma FILA dinâmica
Typedef struct no
{struct no *anterior ;
int matricula;
char nome[30];
struct no *proximo;
} tipoNo;
tipoNo *inicio;
a) A) Pode ser a estrutura de uma fila estática
b) B) Pode ser a estrutura de um registro de vetor
c) C) Pode ser a estrutura de uma lista duplamente encadeada
d) D) Pode ser a estrutura de uma lista encadeada
e) E) Pode ser a estrutura de uma lista estática
F) A) FILO
G) B) LIFO
H) C) UEPS
I) D) LILO
J) E) FIFO
F) A) LIFO
G) B) FILO
H) C) PEPS
I) D) LILO
J) E) FIFO
13) Qual será o estado final da fila, após executar as instruções abaixo:
inicio
Y T F
INC “C”
INC “D”
INC “H”
DEL
DEL
INC “B”
Resposta:
C
A B
Resposta:
1 2 3
S 7 O 3 A 5
4 5 6
R 9 1 B 2
7 8 9
O 4 E T 8
A) BOASORTE
B) BOA SORTE
C) SORTEBOA
D) SORTE BOA
E) SOR TEBOA
1 2 3
X 8 Y 6 Z 9
4 5 6
R 3 T 1 C 4
7 8 9
A 5 G M 7
18) Considerando a lista abaixo que implementa uma PILHA qual será o
primeiro e o último valor a ser excluído desta lista?
Endereço 00 01 02 03 04 05 06
Valor K W I A H Z B
proximo 03 NULL 06 05 02 04 01
A) BEGE- VERMELHO-AMARELO-AZUL-VERDE
B) AZUL-BEGE-VERDE-VERMELHO-AMARELO
C) AMARELO-AZUL-BEGE-VERMELHO-VERDE
D) VERMELHO-AZUL-AMARELO-BEGE-VERDE
E) AZUL-VERMELHO-AMARELO-VERDE-BEGE
aux = inicio;
while (aux != NULL)
{ printf(“\n %c “,aux->valor);
aux = aux->próximo;
}
inicio
letr proxim
o
H K M