Lista 1 - Estruturas de dados I – prof.

Waldemar

Participantes:
Lucas Fabiano Peres Silva - 30102235
Marcelo da Silva Oliveira - 29070031
João Victor Rodrigues Bersonette - 29701317
Vinicius Rosa Santos - 5032158319
Túlio Delazari - 30271967

1. Sobre ponteiros, marque as afirmações como verdadeiras (V) ou falsas (F):

( F ) ponteiro é o valor de uma variável
( F ) ponteiro é o indicador da próxima variável a ser
passada
( V ) ponteiro é uma variável que armazena endereço
( V ) ponteiro é o endereço que aponta para uma variável

2. Quais das seguintes instruções declaram um ponteiro para uma variável float? Marque as afirmações como
verdadeiras (V) ou falsas (F):
(V) float *p;
(F) float p;
(F) *float p;
(F) float p*;

3. No trecho de código a seguir, quais serão os valores de x, y e *p no comando printf?

( ) x=4, y=0, *p=4

( ) x=3, y=3, *p=3
( ) x=-1, y=0, *p=0
(X) x=3, y=4, *p=4

4. No trecho de código a seguir, que valor de c será impresso no comando printf?

()5
(X) 17
( ) 12
()7

5. Descubra o problema no programa a seguir:

A variavél do Ponteiro P não foi iniciada com um endereço válido, isso faz com que quando usado o *P, ele não
consegue determinar o endereço de memório no qual ele seria atribuído. O correto seria adicionar P=&x,
Iniciando para que Ponteiro aponte para a variável X.
 6. Faça um programa que a) Explique a diferença entre p++; (*p)++; *(p++); b) O que quer dizer *(p+10);?
a) “p++” incrementa o valor de 1 na variável p, “(*p)++” incrementa o
valor apontado por p em uma unidade, já “*(p++)” significa que
queremos acessar o valor guardado no espaço de memória que
p representa (usando o símbolo *), e depois aumentar o valor
de p em 1 (usando o símbolo ++). Isso é usado em situações em
que queremos acessar vários valores guardados em sequência
na memória, por exemplo em um array de números.
b) Em C, *(p+10) é uma forma de acessar o conteúdo da posição de
memória apontada pelo ponteiro "p", deslocado 10 posições
adiante na memória. Basicamente, o código está pedindo para
"pular" 10 posições na memória e acessar o valor contido lá.

7. Baseando nos slides sobre listas estáticas (arrays) e dinâmica (ligadas), faça um programa que, dado um
array inicial de tamanho N, que seja do tipo char ou float, não-ordenado, receba novos elementos.
#include <stdio.h>
#include <stdlib.h>

int main()
{
int N = 10;
int contador = 3;
float *arr = (float*) malloc(N * sizeof(float));

arr[0] = 7.24;
arr[1] = 5.71;
arr[2] = 8.21;

printf("Array inicial:\n");
for (int i = 0; i < contador; i++) {
printf("%.2f ", arr[i]);
}
printf("\n\n");

printf("Digite um novo elemento (-1 para encerrar): ");

float novo_elemento;
scanf("%f", &novo_elemento);
while (novo_elemento != -1) {
if (contador == N) {
N *= 2;
arr = (float*) realloc(arr, N * sizeof(float));
}
arr[contador] = novo_elemento;
contador++;
printf("Digite um novo elemento (-1 para encerrar): ");
scanf("%f", &novo_elemento);
}

printf("\nArray final:\n");
for (int i = 0; i < contador; i++) {
printf("%.2f ", arr[i]);
}
printf("\n");

free(arr);

return 0;
}
 8. Baseando nos slides sobre listas estáticas (arrays) e dinâmica (ligadas), faça um programa que, dado um
array inicial de tamanho N, que seja do tipo char ou float, ordenado, receba novos elementos e mantenha a
ordem.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

void bubbleSort(int arr[], int n) {

int i, j, temp;
bool trocou = true;
for (i = 0; i < n-1 && trocou; i++) {
trocou = false;
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
trocou = true;
}
}
}
}

int main() {
int n, i;
printf("Digite o tamanho do array: ");
scanf("%d", &n);
int arr[n];
printf("Digite os elementos do array:\n");
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
bubbleSort(arr, n);
printf("Array ordenado:\n");
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}

9. Baseando nos slides sobre listas estáticas (arrays) e dinâmica (ligadas), faça um programa que, dado um
array inicial de tamanho N que seja do tipo char ou float, não-ordenado, busque e remova um dado
elemento.
#include <stdio.h>
#include <stdlib.h>

#define N 10

int remove_elementos(float arr[], int tam, float item);

int main() {
float arr[N] = {9.5, 1.5, 6.3, 2.0, 3.7, 4.2, 7.8, 8.1, 10.0, 5.0};
int tam = N;

float item;
printf("Digite o item a ser removido: ");
scanf("%f", &item);

int novo_tam = remove_elementos(arr, tam, item);

if (novo_tam < tam) {

printf("Item %.2f removido com sucesso!\n", item);
} else {
printf("Item %.2f nao encontrado.\n", item);
}

printf("Array atualizado:\n[");
for (int i = 0; i < novo_tam; i++) {
printf(" %.2f", arr[i]);
}
printf(" ]\n");

return 0;
}

int remove_elementos(float arr[], int tam, float item) {

int i, j;

for (i = 0; i < tam; i++) {

if (arr[i] == item) {
for (j = i; j < tam - 1; j++) {
arr[j] = arr[j + 1];
}
return tam - 1;
}
}

return tam;
}

10. Baseando nos slides sobre listas estáticas (arrays) e dinâmica (ligadas), faça um programa que, dado um
array inicial de tamanho N, que seja do tipo char ou float, ordenado, busque e remova um dado elemento
elementos e mantenha a ordem.
#include <stdio.h>
#include <stdio.h>

void insertionSort(float arr[], int n) {

int i, j;
float key;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

int main() {
int n, i, j, pos;
float arr[100], x;

printf("Digite o tamanho do array: ");

scanf("%d", &n);

printf("Digite os elementos do array: ");

for (i = 0; i < n; i++) {
scanf("%f", &arr[i]);
}

printf("Digite o elemento a ser removido: ");

scanf("%f", &x);

for (i = 0; i < n; i++) {

if (arr[i] == x) {
pos = i;
break;
}
}

for (i = pos; i < n - 1; i++) {

arr[i] = arr[i + 1];
}
n--;

insertionSort(arr, n);

printf("Array ordenado:\n");
for (i = 0; i < n; i++) {
printf("%.2f ", arr[i]);
}
printf("\n");

return 0;
}