C como inverter uma fila apenas com functions já declaradas

[oJunior1384]

Olá, estou com dificuldades em desenvolver uma lógica onde consiga inverter os valores de uma apenas e somente apenas com as próprias funções já declaradas no exercício

OBS: Em uma FILA, os elementos são adicionados (enfileirados) um a um e no FINAL da fila. Só é possível acessar o PRIMEIRO elemento da fila (INÍCIO da fila). Quanto a retirada de um elemento da fila, sempre ocorre pelo INÍCIO da fila.

#define TAM 5

typedef struct {
    int memória[TAM];
    int fim;
} fila;

void inicializafila (fila *f);
int filacheia (fila *f);
int filavazia (fila *f);
void enfileira (fila *f, int elemento);
void desenfileira (fila *f);
int iniciofila (fila *f);
int tamanhofila (fila *f);
void invertefila (fila *f);

void inicializafila (fila *f) {
    f->fim = 0;
    
}

int filacheia (fila *f) {
    if(f->fim != TAM) return (0);
    return (1);
}

int filavazia (fila *f) {
    if (f->fim != 0) return (0);
    return 1;

}

void enfileira (fila *f, int elemento) {
    if (!filacheia (f)){
        f->memória[f->fim] = elemento;
        f->fim++;
    }
}

void desenfileira (fila *f) {
    int aux, i;
    if(!filavazia(f)){
        for (i = 0; i < (f->fim-1); i++ ){
        f->memória[i] = f->memória[i+1];
        f->fim--;
    }    
}

int iniciofila (fila *f) {
    if (!filavazia (f))
        return f->memória[0];    
}

int tamanhofila (fila *f) {
    return (f->fim);

}

void invertefila (fila *f) {

[Ansi C]

Existe uma lista inicial com duas operações -- retirar e colocar termos, respectivamente no início e no fim da lista. Tua meta será|é construir uma combinação de ‘loops’ e operações (funções) que rotaciona essa lista tantas vezes quanto necessário for para copiar o último termo de cada rotação para uma lista auxiliar. Uma rotação é retirar e colocar o termo retirado da lista n-vezes, tal que n é o tamanho da lista - 1, ou seja, no final de uma rotação o primeiro termo dela era seu último. Notará que na última rotação a lista inicial terá 1 único termo que também é|foi o seu primeiro, que ao colocar na lista auxiliar ficará na sua última posição, enquanto a inicial fica vazia, pois a auxiliar é uma cópia invertida dela. Daí a inicial é vazia e auxiliar é|será a nova inicial invertida. @oJunior1384 é isso?

[oJunior1384]

@mauro_b Não entendi muito bem, mas eu fiz um while para retirar o último termo da lista

while(!filavazia(f)){
        aux=iniciofila(f);
        enfileira(&a,aux);
        desenfileira(f);
    }

porém não consigo seguir adiante para inverter a lista, não posso usar vetores e nem especificar a posição da lista, só posso lidar com as funciton

 

[arfneto]

Em 26/04/2022 às 15:18, oJunior1384 disse:

Olá, estou com dificuldades em desenvolver uma lógica onde consiga inverter os valores de uma apenas e somente apenas com as próprias funções já declaradas no exercício

OBS: Em uma FILA, os elementos são adicionados (enfileirados) um a um e no FINAL da fila. Só é possível acessar o PRIMEIRO elemento da fila (INÍCIO da fila). Quanto a retirada de um elemento da fila, sempre ocorre pelo INÍCIO da fila.

 

Filas tem uma propriedade que é a disciplina --- imagino que apareça assim em português. LIFO e FIFO são os nomes mais comuns para isso para filas em que se extrari primeiro o último inserido ou o primeiro inserido (FIFO). Também existem deques, não sei como seria em português o nome disso, mas são double-ended queues onde pode inserir no início ou no fim.

 

Se você precisa inverter o clássico e mais simples é usar as funçoes e DUAS filas...

Use o botão code. Veja a diferença:

 

 

#define TAM 5

typedef struct {
    int memória[TAM];
    int fim;
} fila;


void inicializafila (fila *f);
int filacheia (fila *f);
int filavazia (fila *f);
void enfileira (fila *f, int elemento);
void desenfileira (fila *f);
int iniciofila (fila *f);
int tamanhofila (fila *f);
void invertefila (fila *f);

void inicializafila (fila *f) {
    f->fim = 0;
    
}

int filacheia (fila *f) {
    if(f->fim != TAM) return (0);
    return (1);
}

int filavazia (fila *f) {
    if (f->fim != 0) return (0);
    return 1;

}

void enfileira (fila *f, int elemento) {
    if (!filacheia (f)){
        f->memória[f->fim] = elemento;
        f->fim++;
    }
}

void desenfileira (fila *f) {
    int aux, i;
    if(!filavazia(f)){
        for (i = 0; i < (f->fim-1); i++ ){
        f->memória[i] = f->memória[i+1];
        f->fim--;
    }    
}

int iniciofila (fila *f) {
    if (!filavazia (f))
        return f->memória[0];    
}

int tamanhofila (fila *f) {
    return (f->fim);

}

void invertefila (fila *f) {

 

Poste algo inteiro, compilável. E o enunciado se possível. Ou uma descrição mais formal do que está tentando resolver

[Ansi C]

2 horas atrás, oJunior1384 disse:

Não entendi muito bem

Tudo bem, eu posso explicar tantas vezes quanto for necessário para entender.

Veja

As operações (funções) de fila uteis|essências para uma solução|algoritmo foram definidas (abaixo):

Em 26/04/2022 às 15:18, oJunior1384 disse:

void inicializafila (fila *f);
int filacheia (fila *f);
int filavazia (fila *f);
void enfileira (fila *f, int elemento);
void desenfileira (fila *f);
int iniciofila (fila *f);
int tamanhofila (fila *f);
void invertefila (fila *f);

Tudo que precisa, digo isso porque tenho uma solução, são delas, @oJunior1384

Existe uma lista inicial com duas operações -- enfileirar e desenfileirar, respectivamente no início e no fim da fila.

Logo

Tua meta será|é construir uma combinação de ‘loops’ e operações (funções) que rotaciona essa lista tantas vezes quanto necessário for para copiar o último termo de cada rotação para uma lista auxiliar.

Rotação:  é posicionar  o último termo da fila na primeiro posição dela, para isso é necessário desenfileira e enfileira n-vezes, ou seja, o tamanho da fila - 1.

Observe que

Se A é uma fila tipo: A [1 2 3 4 5] E aplicar uma rotação em A, cujo tamanho é 5, fará em um ‘loop’ de 4 repetições que tornará a composição da fila A igual à [5 1 2 3 4], isso porque a cada repetição sua máquina faz `a` = início da fila A, desenfileira A e enfileira `a` em A e repete até o fim do ‘loop’-rotação. Em seguida, no fim da ‘loop’-rotação: basta enfileirar na fila B o início da fila A e desenfileirar A.

Assim

Nesse ponto B = [5] e A = [1 2 3 4].

Construa o programa para repetir o processo dessa observação até que a fila A fique com tamanho 0. Sendo assim, precisa de 2 loops. Quando o tamanho da fila A é 0 o loop externo para e a composição será: A = [] e B = [5 4 3 2 1], por tanto, B é A inversa.