Operations with linear queues, moving an element to the first row

Question

I need an algorithm that handles a linear list of type FILA. (In PASCAL, it can either be done in pseudo-code, or C, or whatever is preferable).

The algorithm must take an element from the queue, remove it and insert this element at the beginning. The array that completes the queue must be rearranged (since if you take the element out of the middle, you break the queue).

The FILA is circular, it comes back in itself, I will leave down the structure of the cell made in PASCAL:

type
ElementosF = integer; //tipo de dado que a fila ira receber
fila = record
              memoria:array[1..TAMF] of ElementosF; //memoria da fila
              final,inicio,total:integer; //ultimo, primeiro, total de elemento da fila
             end;

The question is, how do I do that? I’ve tried it in many ways, and I’ve all failed... Thank you

Answer 1

There are several ways to make such an algorithm. I advise you to see the different forms of implementation I put here and try to make your own code.

Row in C.

#include <stdio.h>

#define MAX 5 // numero maximo de elementos na fila

// cria uma fila vazia
int comeco = 0;   // comeco da fila
int tamanho = 0;  // tamanho da fila (numero de elementos)
int queue[MAX];   // vetor da fila

void inserir( int );    // inserir elementos no fim da fila
void remover( void );   // remover elementos do comeco da fila

int main(void)
{
    int i; // contador

    inserir(1);
    inserir(10);
    inserir(100);
    inserir(1000);
    remover();
    inserir(6);
    remover();
    inserir(60);

    //// mostra fila na tela ////
    for(i = 0; i < MAX; i++)
        printf("fila[%i] = %i\n", i, queue);

//  system("pause"); // comente esta linha se for rodar no linux
    return ( 0 );

} // fim main    


void inserir( int elemento )
{
    //// checa se a fila esta cheia ////
    if( tamanho == MAX )
        printf("\nfila cheia\n");

    else {
        //// converte os valores virtuais (tamanho e comeco) para o valor real utilizando o operador modulo ////
        queue[ ((comeco + tamanho) % MAX) ] = elemento; 
        //// incrementa tamanho da fila (elemento foi inserido) ////
        tamanho ++; 
    } 

} // fim funcao


void remover(void)
{
    //// checa se a fila esta vazia ////
    if( tamanho == 0 )
        printf("\nfila vazia\n");

    else {
        //// apaga o primeiro elemento da fila deslocando o ponteiro do comeco para proximo elemento ////
        comeco ++;
        //// decrementa o contador de tamanho (um valor foi removido) ////
        tamanho --;
    }

} // fim funcao

See working on Ideone

In the internet has several algorithms ready, see this website. It even details each function. In this website, also has another implementation.