C Remover elemento de uma fila com prioridade

MJacobsen · 4 de junho de 2020

Código não retorna como vazia no ultimo elemento a ser retirado , sendo necessário remover primeiro elemento de prioridade 1 ate o total de 3 ou termino da fila , depois 2 de prioridade 2 ou termino da fila e por ultimo 1 de prioridade 3. Se alguém puder me tirar essa duvida , já virei de cabeça pra baixo .

Fila_Com_Prioridade.rar

arfneto · 4 de junho de 2020

Postar um link para um arquivo no formato rar, que não tem suporte nativo como zip em muitos sistemas, faz com que seja preciso

instalar um programa,
fazer um download,
sair do contexto do forum para abrir um arquivo,
extrair o conteúdo
e quem sabe abrir em um compilador, para tentar ajudar em sua dúvida.

Não pode simplesmente postar o programa, podendo assim atingir mais gente e ajudar mais gente que venha a ler o tópico?

MJacobsen · 5 de junho de 2020

@arfneto ah sim obrigado pela dica .

adicionado 4 minutos depois

#include <stdio.h>
#include <stdlib.h>
#include<conio.h>
#include<stdbool.h>
#include<locale.h>
#include<string.h>

typedef struct dados{
    char nome[40];
    int prioridade;
    struct dados *prox;
}Dados;

typedef struct fila {
    Dados *inicio;
    Dados *fim;
    int quantidade;
}Fila;
int contador_prioridade1=0;
int contador_prioridade2=0;
int contador_prioridade3=0;

Fila queue;
/*Inicializa a fila e atribui nulo aos ponteiros que receberao
endereços dos dados e determina quantidade 0 para informar que
a lista esta vazia*/

void inicializarFila(Fila *apontador){
    apontador->inicio = NULL;
    apontador->fim = NULL;
    apontador->quantidade = 0;
    printf("\t\t|Fila Inicializada|\n");
}

bool vazia(Fila *apontador){
    return(apontador->inicio == NULL);
}

void insere(Fila *apontador,char *Nome,int *priori) {
	Dados *novo = (Dados*)malloc(sizeof(Dados));

	strcpy(novo->nome , Nome);//add nome
	novo->prioridade = *priori;// add priori
	novo->prox = NULL;

	if(apontador->inicio == NULL){
        apontador->inicio = novo;
        apontador->fim = novo;
        apontador->quantidade++;
	}else{
	    apontador->fim->prox = novo;
	    apontador->fim = novo;
	    apontador->quantidade++;

	}
	printf("\nElemento inserido com sucesso\n");

}

int remove_elemento(Fila * apontador){
    printf("\nREMOVENDO ELEMENTOS AGUARDE ...\n");
    if(apontador == NULL) return 0;

    Dados *anterior,*novo = apontador->inicio;
    if(contador_prioridade1<3){
    while(novo != NULL && novo->prioridade !=1 && contador_prioridade1 <=3){
            anterior = novo;
            novo = novo->prox;
            if(novo->prioridade == 1){
                contador_prioridade1++;

            }
    }
    }else if(contador_prioridade2<2){


    while(novo!= NULL && novo->prioridade !=2 && contador_prioridade2 <=2){
            anterior = novo;
            novo = novo->prox;
            if(novo->prioridade == 2){
                contador_prioridade2++;

            }
    }}else{
    while(novo != NULL && novo->prioridade !=3 && contador_prioridade3<=1){
            anterior = novo;
            novo = novo->prox;
            if(novo->prioridade == 3){
                contador_prioridade3++;

            }
    }}
    if(apontador->inicio == NULL) return 0;

    if(novo == apontador->inicio)
        apontador->inicio = novo->prox;
    else
        anterior->prox = novo->prox;

    free(novo);
    apontador->quantidade--;
    return 1;
}

void exibir_fila(Fila *apontador) {
	Dados *aux = apontador->inicio;
    int i=1;
	if(apontador->inicio==NULL) {
		printf("\n\tNÃO HÁ MAIS ELEMENTOS NA FILA !!!\n");
		return;
	}

	while(aux != NULL) {
		printf("\n%dº-NOME - %s ",i++, aux->nome);
		printf("Prioridade   - %d  \n",aux->prioridade);
        aux = aux->prox;
	}
	printf("\nQuantidade de elementos na FILA |%d|\n\n",apontador->quantidade);
}
//terminar as prioridades de saida//
void exibe_muitos(Fila *apontador){

    Dados *aux = apontador->inicio;
    int i=1,qtd_elementos = 0;
	if(apontador->inicio==NULL) {
		printf("\tERRO: Fila vazia");
		return;
	}

	while(aux != NULL && qtd_elementos <6) {
		printf("\n %dº-NOME: %s ",i++, aux->nome);
		printf("Prioridade:  %d \n",aux->prioridade);
		aux = aux->prox;
		qtd_elementos++;

    }
    if(qtd_elementos < 5){
        printf("\nNão há mais elementos\n");
	}
}
//Menu das opções//
void menu() {
	printf("\n\t##############################################");
	printf("\n\t#               MENU - FILA                  #");
	printf("\n\t#                                            #");
	printf("\n\t#	  Digite a opção desejada            #");
	printf("\n\t#                                            #");
	printf("\n\t#	 1 = Inserir na FILA                 #");
	printf("\n\t#	 2 = Remover da FILA                 #");
	printf("\n\t#	 3 = Exibir FILA                     #");
	printf("\n\t#	 4 = Exibir 6 próximos da FILA       #");
	printf("\n\t#	 0 = Sair                            #");
	printf("\n\t#                                            #");
	printf("\n\t##############################################");
	printf("\t\n\n");
}

int main(){
    setlocale(LC_ALL,"portuguese");

    int res,op,valor=0;
    bool i=true;
    char nome[40];

    inicializarFila(&queue);

    do{
            menu();
            op = getche()-'0';
            switch(op){
                case 1:
                    system ("cls");
                    printf("\nDigite o nome a ser inserido :\n");
                    fgets(nome,40,stdin);
                    system("cls");
                    do{
                        system("cls");
                        printf("\nDigite a prioridade(De 1 a 3):\n");
                        scanf("%d",&valor);
                    }while(valor < 1 || valor > 3);

                    insere(&queue,nome,&valor);
                    setbuf(stdin,NULL);
                    break;

                case 2:
                    res = remove_elemento(&queue);
                    if(res == 1){

                        printf("\nITEM REMOVIDO\n");
                    }else{

                        printf("\n\tFILA VAZIA\n");
                    }
                    break;

                case 3:
                    system ("cls");
                    exibir_fila(&queue);
                    break;

                case 4:
                    system ("cls");
                    exibe_muitos(&queue);
                    break;

                case 0:
                    system ("cls");
                    printf("\n\nAté Logo\n");
                    i = false;
                    return 0;

                default:
                    system ("cls");
                    printf("\nOPÇÃO INVÁLIDA\n");
                    menu();
        }
    }while(op != 0);
    system("pause");
    return 0;
}

Problema na função remover , sendo a ordem primeiro 3 elementos 1 ou fim da fila, 2 elementos 2 ou fim da fila e 1 elemento 3 ou fim da fila

arfneto · 5 de junho de 2020

31 minutos atrás, MJacobsen disse:

Problema na função remover , sendo a ordem primeiro 3 elementos 1 ou fim da fila, 2 elementos 2 ou fim da fila e 1 elemento 3 ou fim da fila

Vou ver se encontro algo. Deu uma lida no código e parece muito complicado, talvez sem necessidade

Uma coisa que posso dizer:

provavelmente os contadores de prioridade deveriam estar dentro da estrutura
main() deve ser a primeira função de todo programa. Use protótipos no início. E se não tem um critério lógico importante, use a ordem alfabética.
conio.h é uma herança dos anos 80. Não deveria ser usada pra nada. E não há razão mesmo.
getche() não deveria mais ser usada desde os '80. Seu compilador não reclamou de nada?
Se op é a opção do menu porque não retornar isso de menu()? Evite void a qualquer custo. Em geral se pode ou deve retornar algo de toda função. Inclusive main()
um switch '1' é tão bom quanto um switch 1: para que perder tempo com
```
        op = getche() - '0';
```
se não faz diferença?
Procure usar o menu direto de um arquivo. É muito mais simples e flexível. E leia a opção no final do menu e retorne o valor. É mais esperto

Está programando uma Fila de prioridade? A própria Priority Queue?

arfneto · 5 de junho de 2020

Mais umas coisas: Você não implementou o que seria uma porque normal, apenas usou uma lista ligada. E está ok. A implementação é algo que deve mesmo sumir dentro do programa. No entanto:

Não use variáveis globais. É uma dor de cabeça garantida. Não por acaso todos autores condenam, empresas proíbem, professores proíbem, e eu reclamo Fuja disso. Passe parâmetros. E em C endereços.
Não coloque dados de sua estrutura nas chamadas a insere() ou qualquer outra. É problema. Use se possível uma caixa preta, um ponteiro para Dados ou void mesmo. Na semana que vem sua lista será de livros, depois de músicas, depois de produtos.
Sua rotina remove()está muito complicada e frágil, com vários loops no meio de cadeias de if() . Acho que foi complicando à medida em que foi tentando implementar a lógica de atendimento

Estive pensando rapidamente no seu problema no almoço aqui. Eis o que acho que custaria menos esforço para concluir seu programa:

Acho que as rotinas estão ok. Parecem mais ou menos com o código padrão de listas. Os parâmetros não estão bons, como falei. Mas pode funcionar assim como escreveu.
Ao entrarem elementos na fila, apenas coloque no fim da fila. Mas ao final da inserção rode uma função ajuste() que coloca os caras do início da fila em conformidade com a disciplina. E na hora de atender atende sempre o primeiro da fila, de modo que as funções insere() e remove() ficam triviais como as de toda lista ligada.

E a função de ajuste?

Não é complexo, e você vai ter que implementar essa lógica de qualquer maneira. Escreva uma função helper para trocar um cara de posição na fila. Não é difícil e se trabalha apenas com ponteiros pode trocar só o endereço dos dados.

A lógica é que na fila os caras estão por ordem de chegada, mas no topo da fila se possível tem 3 caras P1, 2 P2 e um P3.

Pode usar um vetor

    int disciplina[6] = { 1, 1, 1, 2, 2, 3 }; // controle

Para ajudar a ajustar. Só isso. Então sua fila tem uma área gerenciada onde tem no máximo seis elementos. E o resto, se tiver. E serão atendidos por ordem de chegada, dentro da disciplina. É como se no mundo real tivesse um estagiário organizando a fila.

Pense nisso.

MJacobsen · 5 de junho de 2020

@arfneto Muito obrigado pelas dicas , vou alterar as variáveis e utilizar os parâmetros , e sim a função remover foi a que mais tive que refazer , nossa esclareceu alguns pontos que eu estava com duvida obrigado mesmo

arfneto · 5 de junho de 2020

Veja essa rotina por exemplo:

int ajuste()
{
    int disciplina[6] = { 1, 1, 1, 2, 2, 3 };
    static int primeiro = 0;

    printf("Fila: ");
    for (int i = 0; i < 6; i += 1)
    {
        printf("%d ", disciplina[(primeiro+i)%6]);
    };  // for()
    printf("\n");
    primeiro = (primeiro + 1) % 6;
    return 0;
}

Se você chamar 20 vezes:

Fila: 1 1 1 2 2 3
Fila: 1 1 2 2 3 1
Fila: 1 2 2 3 1 1
Fila: 2 2 3 1 1 1
Fila: 2 3 1 1 1 2
Fila: 3 1 1 1 2 2
Fila: 1 1 1 2 2 3
Fila: 1 1 2 2 3 1
Fila: 1 2 2 3 1 1
Fila: 2 2 3 1 1 1
Fila: 2 3 1 1 1 2
Fila: 3 1 1 1 2 2
Fila: 1 1 1 2 2 3
Fila: 1 1 2 2 3 1
Fila: 1 2 2 3 1 1
Fila: 2 2 3 1 1 1
Fila: 2 3 1 1 1 2
Fila: 3 1 1 1 2 2
Fila: 1 1 1 2 2 3
Fila: 1 1 2 2 3 1

Esse é o serviço do "fiscal da fila" e a cada vez é chamado o cenário muda. Na 5 vez tem que atender P2, se não tiver passa para o P3, por exemplo. Como ajuste() tem sua própria memória, que seria a prancheta do estagiário, a cada vez que entra alguém a coisa se arruma sem ter que mexer na fila.

Note que essa não é a estrutura de dados Priority Queue. Se seu enunciado não exige isso, tudo certo.

Seu programa não está bom, nem a estrutura dos dados. Entenda as razões que mostrei.