Escrever a função int menor(int n, int v[], int* p ), que retorna o menor elemento do vetor v, de n elementos, e retorna na variável p a posição do menor elemento no vetor v. Escrever a função void ordenar(int n, int v[] ), que recebe como parâmetros o tamanho ( n ) de um vetor ( v ) e retorna o próprio vetor v, com os valores em ordem crescente. A função ordenar deve implementar o seguinte algoritmo:
Seja w um vetor do tamanho do vetor v;
Seja M uma constante bem grande;
Para i = 0 até n-1 fazer:
{
    m = menor(n, v, &p);
    w[i] = m;
    v[p] = M;
}
Para i = 0 até n-1 fazer:
{
    v[i] = w[i];
}
Escrever um programa que: lê o valor de n, gera o vetor v aleatoriamente, chama a função ordenar e mostra o vetor v ordenado.

Passo 1

O enunciado pede para criarmos duas funções em C: uma int menor(int n, int v[], int *p) que encontra o menor valor em v de tamanho n e devolve esse valor, bem como a posição via ponteiro p; e outra void ordenar(int n, int v[]) que usa um vetor auxiliar w e uma constante grande M para ordenar v em ordem crescente seguindo o algoritmo dado. Depois, no programa principal, a gente lê n, preenche v com valores aleatórios, chama ordenar e imprime o vetor resultante.

Passo 2

Para a função menor, a ideia é percorrer todo o vetor v comparando cada elemento com um mínimo armazenado. A gente inicializa o mínimo como v[0] e sua posição p como 0. Em seguida, para i de 1 até n-1, se v[i] for menor que o mínimo atual, atualizamos o mínimo e p. No fim retornamos o mínimo e, via ponteiro, a posição.

Passo 3

Para a função ordenar, vamos:
  1. Declarar um vetor auxiliar w de tamanho n.
  2. Definir uma constante M bem grande (por exemplo 1000000) para marcar elementos já usados.
  3. Fazer um laço i de 0 até n-1: chamar menor(n, v, &p), guardar o valor retornado em w[i] e sobrescrever v[p] com M.
  4. Depois copiar de volta todos os w[i] para v[i], assim v fica ordenado.

Passo 4

No programa principal (main), incluímos as bibliotecas <stdio.h>, <stdlib.h>, <time.h>. Lemos n, alocamos v dinamicamente com malloc(n * sizeof(int)), inicializamos srand(time(NULL)), preenchemos v com valores de rand()%100 ou outro intervalo desejado, chamamos ordenar(n, v), imprimimos v e liberamos memória com free(v).

Resposta

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int menor(int n, int v[], int *p) {
int m = v[0];
*p = 0;
for (int i = 1; i < n; i++) {
if (v[i] < m) {
m = v[i];
*p = i;
}
}
return m;
}
void ordenar(int n, int v[]) {
int *w = malloc(n * sizeof(int));
if (!w) {
fprintf(stderr, “Erro de alocacao\n”);
return;
}
const int M = 1000000000; // constante bem grande
int p;
for (int i = 0; i < n; i++) {
int m = menor(n, v, &p);
w[i] = m;
v[p] = M;
}
for (int i = 0; i < n; i++) {
v[i] = w[i];
}
free(w);
}
int main() {
int n;
printf(“Digite o tamanho do vetor: “);
if (scanf(”%d”, &n) != 1 || n <= 0) {
printf(“Entrada invalida.\n”);
return 1;
}
int *v = malloc(n * sizeof(int));
if (!v) {
fprintf(stderr, “Erro de alocacao\n”);
return 1;
}
srand((unsigned) time(NULL));
for (int i = 0; i < n; i++) {
v[i] = rand() % 100; // valores de 0 a 99
}
ordenar(n, v);
printf(“Vetor ordenado:\n”);
for (int i = 0; i < n; i++) {
printf("%d “, v[i]);
}
printf(”\n");
free(v);
return 0;
}

Exercícios relacionados