Considere que um Técnico Programador escreveu um programa pa...

A alternativa correta é C - pilha.

Para resolver essa questão, é necessário compreender o funcionamento das estruturas de dados e suas características. Vamos analisar como cada estrutura de dados funciona e por que a pilha é a escolha correta.

Pilha:

Uma pilha é uma estrutura de dados que segue o princípio LIFO (Last In, First Out), ou seja, o último elemento que entra é o primeiro a sair. Isso significa que, ao inserirmos os dígitos na pilha e depois removê-los um a um, obteremos os dígitos na ordem inversa à que foram inseridos. No contexto da questão, ao ler um número de 6 dígitos e inseri-los na pilha, ao removê-los, obteremos o número invertido. Por exemplo, se inserirmos os dígitos do número 123456 na pilha, ao removê-los, obteremos 654321. Portanto, a alternativa C é a correta.

Fila Circular:

Uma fila circular é uma variação da fila tradicional onde o último elemento se conecta ao primeiro, formando um círculo. No entanto, filas seguem o princípio FIFO (First In, First Out), ou seja, o primeiro elemento a ser inserido é o primeiro a ser removido. Se utilizássemos uma fila para essa operação, os dígitos seriam retirados na mesma ordem em que foram inseridos, não permitindo a inversão do número. Portanto, a alternativa A está incorreta.

Fila não circular:

Semelhante à fila circular, uma fila não circular também segue o princípio FIFO. Isso significa que os elementos são removidos na mesma ordem em que foram inseridos. Novamente, isso não permitirá a inversão do número. Por isso, a alternativa B está incorreta.

Lista linear do tipo FIFO:

Uma lista linear do tipo FIFO também opera sob o princípio FIFO, assim como as filas. Isso significa que a ordem dos elementos será mantida ao serem removidos da lista. Portanto, não é possível obter o número invertido usando essa estrutura. Sendo assim, a alternativa D está incorreta.

Árvore binária:

Uma árvore binária de altura específica (neste caso, log₂6 - 1) é uma estrutura de dados mais complexa, usada principalmente para operações de busca e ordenação eficiente. No entanto, ela não é adequada para a inversão direta da ordem dos dígitos como exigido na questão. Portanto, a alternativa E está incorreta.

Em resumo, a estrutura de dados que permite a inversão direta dos dígitos ao remover os elementos na ordem inversa à de inserção é a pilha. Por isso, a alternativa C é a correta.

Uma pilha é uma estrutura de dados que admite remoção de elementos e inserção de novos objetos.  Mais especificamente, uma  pilha (= stack)  é uma estrutura sujeita à seguinte regra de operação:  sempre que houver uma remoção, o elemento removido é o que está na estrutura há menos tempo.

Em outras palavras, o primeiro objeto a ser inserido na pilha é o último a ser removido. Essa política é conhecida pela sigla LIFO (= Last-In-First-Out).

Fonte: https://www.ime.usp.br/~pf/algoritmos/aulas/pilha.html 

Inserindo na pilha os digitos de um número e retirando em seguida vou ter o numero invertido, mas não entendi para que serve essa parte:

" multiplicados pelo valor posicional correto e somados "

O algoritmo faz uso de uma pilha (stack) sim, mas não basta retirar os valores a partir do topo da pilha pois o resultado esperado é um número inteiro e não uma string (de dígitos) invertida. É uma questão complexa! Vou colocar o algoritmo (Java) para que possamos entender melhor isso.

// Java program to reverse the number

// using a stack

import java.util.Stack;

public class GFG

{

    // Stack to maintain order of digits

    static Stack st= new Stack<>();

    // Function to push digits into stack

    static void push_digits(int number)

    {

        while(number != 0)

        {

            st.push(number % 10);

            number = number / 10;

        }

    }

    // Function to reverse the number

    static int reverse_number(int number)

    {

        // Function call to push number's

        // digits to stack

        push_digits(number);

        int reverse = 0;

        int i = 1;

        // Popping the digits and forming

        // the reversed number

        while (!st.isEmpty())

        {

            reverse = reverse + (st.peek() * i);

            st.pop();

            i = i * 10;

        }

        // Return the reversed number formed

        return reverse;

    }

    // Driver program to test above function

    public static void main(String[] args)

    {

        int number = 39997;

        System.out.println(reverse_number(number));

    }

}

A parte da questão que diz: "multiplicados pelo valor posicional correto e somados, obtendo-se o número invertido" é vista no algoritmo dentro do while:  reverse = reverse + (st.peek() * i);

Pilha = LIFO -> Last in, first out (último a entrar, primeiro a sair)

Fila = FIFO -> Fisrt in, first out (primeiro a entrar, primeiro a sair)

Vamos utilizar um número com apenas 03 dígitos para simplificar

Para se inverter o um número, primeiramente armazena-se este em uma pilha: ex: 123456 armazenado dígito a dígito fica 1,2,3

Como na pilha o último a entrar é o primeiro a sair, a ordem de retirada será 3,2,1

Multiplicar pelo valor posicional significa multiplicar o dígito das centenas por 100, das dezenas por 10 e das unidades por 1:

3*100+2*10+1*1 = 321

Portanto a estrutura deve ser uma pilha, alternativa C