Encontrando os Maiores e Menores Elementos de um Array em C

CBeginner
Pratique Agora

Introdução

Encontrar os elementos maiores e menores em um array é um problema comum na programação que você encontrará frequentemente. Essa habilidade é essencial para várias aplicações, como análise de dados, desenvolvimento de jogos e algoritmos de ordenação.

Neste laboratório, você aprenderá como escrever um programa C que identifica tanto o maior quanto o menor elemento em um array de inteiros. Vamos dividir o processo em etapas claras e gerenciáveis para ajudá-lo a entender a lógica por trás dessa técnica fundamental de programação.

Encontrando os elementos maiores e menores em um array

Este laboratório requer conhecimento básico de programação em C, incluindo variáveis, arrays, loops e instruções condicionais. Ao final desta sessão, você terá criado um programa C completo que demonstra como encontrar valores extremos em um conjunto de dados.

Configurando a Estrutura do Programa

Vamos começar criando um novo arquivo C e configurando a estrutura básica do nosso programa. Isso incluirá os arquivos de cabeçalho (header files) necessários, a função main e as declarações de variáveis.

Primeiro, navegue até o diretório do projeto e crie um novo arquivo chamado main.c:

cd ~/project
touch main.c

Agora, abra o arquivo main.c no editor e adicione o seguinte código:

#include <stdio.h>

int main() {
    // We'll declare an array with a maximum capacity of 50 elements
    int array[50];
    // Variables to store the size of the array and loop counter
    int size, i;
    // Variables to store the largest and smallest elements
    int largest, smallest;

    printf("Finding Largest and Smallest Elements in an Array\n");
    printf("------------------------------------------------\n\n");

    return 0;
}

Este código configura a estrutura básica do nosso programa. Vamos entender o que cada parte faz:

  • #include <stdio.h> inclui a biblioteca padrão de entrada/saída, que fornece funções como printf() e scanf().
  • A função main() é o ponto de entrada do nosso programa.
  • Declaramos um array de inteiros chamado array com uma capacidade de 50 elementos.
  • A variável size armazenará o número de elementos que o usuário deseja inserir.
  • A variável i será usada como um contador de loop.
  • As variáveis largest e smallest armazenarão os valores máximo e mínimo encontrados no array.

Salve o arquivo após adicionar este código. Isso estabelece a base para o nosso programa.

Obtendo a Entrada do Usuário

Agora que temos a estrutura do nosso programa pronta, vamos adicionar código para obter a entrada do usuário. Precisamos pedir ao usuário o tamanho do array e, em seguida, coletar os elementos do array.

Abra o arquivo main.c no editor e modifique-o adicionando o seguinte código antes da instrução return 0;:

// Ask user for the size of the array
printf("Enter the size of the array (max 50): ");
scanf("%d", &size);

// Validate the input size
if (size <= 0 || size > 50) {
    printf("Invalid array size. Please enter a size between 1 and 50.\n");
    return 1;
}

// Get array elements from the user
printf("\nEnter %d elements of the array:\n", size);
for (i = 0; i < size; i++) {
    printf("Element %d: ", i + 1);
    scanf("%d", &array[i]);
}

// Display the entered array
printf("\nThe array you entered is: [ ");
for (i = 0; i < size; i++) {
    printf("%d ", array[i]);
}
printf("]\n\n");

Este código:

  1. Solicita ao usuário que insira o tamanho do array.
  2. Valida se o tamanho está entre 1 e 50.
  3. Pede ao usuário para inserir cada elemento do array um por um.
  4. Exibe o array inserido de volta ao usuário para confirmar.

Vamos compilar e executar nosso programa para ver o que temos até agora:

gcc main.c -o main
./main

Você deve ver um prompt pedindo o tamanho do array. Insira um número pequeno como 5 e, em seguida, insira 5 valores. O programa exibirá o array que você inseriu.

Por exemplo, se você inserir 5 para o tamanho e, em seguida, inserir os valores 10, 25, 5, 17 e 9, você deverá ver a seguinte saída:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Agora que coletamos os elementos do array do usuário, podemos prosseguir para encontrar os valores maiores e menores.

Encontrando o Maior Elemento

Agora, vamos adicionar código para encontrar o maior elemento no array. A estratégia é:

  1. Assumir que o primeiro elemento é o maior.
  2. Comparar cada elemento subsequente com o maior atual.
  3. Se um elemento maior for encontrado, atualizar o valor do maior.

Adicione o seguinte código ao seu arquivo main.c, antes da instrução return 0;:

// Initialize largest with the first element of the array
largest = array[0];

// Find the largest element
printf("Finding the largest element...\n");
for (i = 1; i < size; i++) {
    if (array[i] > largest) {
        largest = array[i];
        printf("New largest found at position %d: %d\n", i + 1, largest);
    }
}

printf("\nThe largest element in the array is: %d\n\n", largest);

Este código inicializa a variável largest com o primeiro elemento do array. Em seguida, itera pelo array começando do segundo elemento (índice 1), comparando cada elemento com o valor maior atual. Se um elemento maior for encontrado, ele atualiza a variável largest e imprime uma mensagem.

Vamos compilar e executar nosso programa para ver os resultados:

gcc main.c -o main
./main

Insira o tamanho e os elementos do array como antes. Por exemplo, se você inserir os valores 10, 25, 5, 17 e 9, você deverá ver uma saída semelhante a:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Finding the largest element...
New largest found at position 2: 25

The largest element in the array is: 25

Isso demonstra como nosso programa encontra o maior elemento no array. O algoritmo começa com o primeiro elemento como o maior e atualiza sempre que encontra um valor maior.

Encontrando o Menor Elemento

Agora que encontramos o maior elemento, vamos adicionar código para encontrar o menor elemento no array. A estratégia é semelhante:

  1. Assumir que o primeiro elemento é o menor.
  2. Comparar cada elemento subsequente com o menor atual.
  3. Se um elemento menor for encontrado, atualizar o valor do menor.

Adicione o seguinte código ao seu arquivo main.c, antes da instrução return 0;:

// Initialize smallest with the first element of the array
smallest = array[0];

// Find the smallest element
printf("Finding the smallest element...\n");
for (i = 1; i < size; i++) {
    if (array[i] < smallest) {
        smallest = array[i];
        printf("New smallest found at position %d: %d\n", i + 1, smallest);
    }
}

printf("\nThe smallest element in the array is: %d\n", smallest);

Este código inicializa a variável smallest com o primeiro elemento do array. Em seguida, itera pelo array começando do segundo elemento (índice 1), comparando cada elemento com o valor menor atual. Se um elemento menor for encontrado, ele atualiza a variável smallest e imprime uma mensagem.

Vamos compilar e executar nosso programa para ver os resultados completos:

gcc main.c -o main
./main

Insira o tamanho e os elementos do array como antes. Por exemplo, se você inserir os valores 10, 25, 5, 17 e 9, você deverá ver uma saída semelhante a:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Finding the largest element...
New largest found at position 2: 25

The largest element in the array is: 25

Finding the smallest element...
New smallest found at position 3: 5

The smallest element in the array is: 5

Isso demonstra como nosso programa encontra tanto o maior quanto o menor elemento no array. Os algoritmos começam com o primeiro elemento e atualizam sempre que encontram um valor maior ou menor, respectivamente.

Otimizando o Programa e Código Completo

Agora que temos um programa funcionando, vamos otimizá-lo combinando a busca pelos maiores e menores elementos em um único loop. Isso é mais eficiente, pois só precisamos percorrer o array uma vez em vez de duas.

Abra o arquivo main.c e substitua todo o conteúdo pela seguinte versão otimizada:

#include <stdio.h>

int main() {
    // We'll declare an array with a maximum capacity of 50 elements
    int array[50];
    // Variables to store the size of the array and loop counter
    int size, i;
    // Variables to store the largest and smallest elements
    int largest, smallest;

    printf("Finding Largest and Smallest Elements in an Array\n");
    printf("------------------------------------------------\n\n");

    // Ask user for the size of the array
    printf("Enter the size of the array (max 50): ");
    scanf("%d", &size);

    // Validate the input size
    if (size <= 0 || size > 50) {
        printf("Invalid array size. Please enter a size between 1 and 50.\n");
        return 1;
    }

    // Get array elements from the user
    printf("\nEnter %d elements of the array:\n", size);
    for (i = 0; i < size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &array[i]);
    }

    // Display the entered array
    printf("\nThe array you entered is: [ ");
    for (i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("]\n\n");

    // Initialize largest and smallest with the first element
    largest = smallest = array[0];

    // Find both the largest and smallest elements in a single pass
    printf("Searching for largest and smallest elements...\n");
    for (i = 1; i < size; i++) {
        // Check for largest
        if (array[i] > largest) {
            largest = array[i];
            printf("New largest found at position %d: %d\n", i + 1, largest);
        }

        // Check for smallest
        if (array[i] < smallest) {
            smallest = array[i];
            printf("New smallest found at position %d: %d\n", i + 1, smallest);
        }
    }

    // Display results
    printf("\nResults:\n");
    printf("- The largest element in the array is: %d\n", largest);
    printf("- The smallest element in the array is: %d\n", smallest);

    // Calculate and display the range
    printf("- The range (difference between largest and smallest) is: %d\n", largest - smallest);

    return 0;
}

Esta versão otimizada:

  1. Usa um único loop para encontrar tanto o maior quanto o menor elemento, tornando o programa mais eficiente.
  2. Inicializa tanto largest quanto smallest com o primeiro elemento do array.
  3. Adiciona um cálculo para o intervalo (a diferença entre os valores maior e menor).

Vamos compilar e executar nosso programa otimizado:

gcc main.c -o main
./main

Insira o tamanho e os elementos do array como antes. Por exemplo, se você inserir os valores 10, 25, 5, 17 e 9, você deverá ver uma saída semelhante a:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Searching for largest and smallest elements...
New largest found at position 2: 25
New smallest found at position 3: 5

Results:
- The largest element in the array is: 25
- The smallest element in the array is: 5
- The range (difference between largest and smallest) is: 20

Esta versão otimizada fornece os mesmos resultados que antes, mas é mais eficiente e inclui informações adicionais sobre o intervalo de valores.

Ao trabalhar com arrays grandes, essas melhorias de eficiência podem reduzir significativamente o tempo de computação, o que é uma consideração importante na programação.

Resumo

Neste laboratório, você criou com sucesso um programa em C que encontra tanto o maior quanto o menor elemento em um array. Vamos revisar o que você aprendeu:

  1. Você configurou uma estrutura básica de programa com as declarações de variáveis necessárias.
  2. Você escreveu código para obter a entrada do usuário para o tamanho e os elementos do array.
  3. Você implementou um algoritmo para encontrar o maior elemento no array.
  4. Você implementou um algoritmo semelhante para encontrar o menor elemento no array.
  5. Você otimizou o programa combinando ambas as buscas em um único loop e adicionou funcionalidade extra.

Este laboratório cobriu vários conceitos fundamentais de programação:

  • Arrays e travessia de arrays (array traversal)
  • Usando loops para iteração
  • Declarações condicionais
  • Otimização de algoritmos
  • Obtenção e validação da entrada do usuário

Essas habilidades são essenciais para qualquer programador e formam a base para estruturas de dados e algoritmos mais complexos. A capacidade de encontrar valores extremos em um conjunto de dados é um requisito comum em muitos cenários de programação, como encontrar as pontuações mais altas em jogos, analisar leituras de temperatura ou processar dados financeiros.

Você pode estender este programa ainda mais adicionando recursos como:

  • Encontrar a média de todos os elementos do array
  • Ordenar o array
  • Encontrar o valor da mediana
  • Contar ocorrências de valores específicos

Continue praticando esses conceitos para fortalecer suas habilidades de programação.