C Calcular o segundo maior elemento da fila!

[Anny Silva]

vou criar um fila , onde se insere numeros ,como eu crio a função de calcular o segundo maior elemento dessa fila ?
 

#include 

struct Fila {
    int capacidade;
    float *dados;
    int primeiro;
    int ultimo;
    int nItens; 
};

void criarFila( struct Fila *f, int c ) { 
    f->capacidade = c;
    f->dados = (float*) malloc (f->capacidade * sizeof(float));
    f->primeiro = 0;
    f->ultimo = -1;
    f->nItens = 0; 
}

void inserir(struct Fila *f, int v) {
    if(f->ultimo == f->capacidade-1)
        f->ultimo = -1;

    f->ultimo++;
    f->dados[f->ultimo] = v; // incrementa ultimo e insere
    f->nItens++; // mais um item inserido
}

 

[Anny Silva]

 void maiorMenorElemento( fila *f)
{
if(vaziaFila((f))
return 0;
int maior ,menor,i;
maior=f.elemento[f.frente];
menor=f.elemento[f.frente];

for(i=f.frente;i<-f.final;i++)
{
if(f.elemento[i]>maior)
maior-f.elemento[i];
if(f.elemento [i]<menor)
menor-f.elemento[i];

}
printf("Maior :%d :",maior);
return 1;
}

[arfneto]

9 horas atrás, Anny Silva disse:

vou criar um fila , onde se insere numeros ,como eu crio a função de calcular o segundo maior elemento dessa fila ?

 

 Você em recebido projetos curiosos. Depois de achar uma proporção de elementos pares numa pilha de números agora precisa do segundo maior elemento numa fila. 

 

Alguém está subvertendo a noção de estruturas de dados no seu curso. 

• numa pilha não há sentido em calcular valores estatísticos do conteúdo. Nada do conteúdo. Todo o sentido de implementar uma pilha é esconder TODOS os elementos EXCETO o primeiro. Isso é pilha. Insere, Remove, Olha o topo. Só isso. Quando se precisa de mais que isso não se usa uma pilha
• numa fila importa o tamanho da fila, o próximo e em alguns casos o tamanho. Se o importante é o tamanho insere na ordem. Precisa do segundo maior? Se tiver ao menos dois será primeiro->prox.

De todo modo se precisa escrever isso apenas melhore sua estrutura e coloque lá o maior e o segundo maior, por exemplo...

 

Escreva em torno dos dados 

 

Sua fila não é de números reais. É de nós, como toda fila. E os nós apontam para números reais.

 

Veja esse trecho:

 

typedef float Dado;

typedef struct st_node
{
    Dado*           dado;
    struct st_node* ant;
    struct st_node* prox;

} Node;

typedef struct
{
    int   capacidade;
    int   nItens;
    Node* primeiro;
    Node* ultimo;

    Node* maior;    // se precisa disso
    Node* segundo;  // o mais simples e manter aqui

} Fila;

Fila* criar();
Fila*  apagar(Fila* fila);
int   inserir(Dado* dado, Fila* elemento);

 

Exceto pelos campos maior e segundo esse é o modo comum de escrever isso. E é comum porque é mais fácil, mais flexível e seguro.

 

Evite retornar void. Em geral é um desperdício. Retorne algo. E receba argumentos.

 

 

[Anny Silva]

@arfneto  meu professor que passaa esses exercicios ,tenho um exercicio onde tem que criar uma  arvore binária e calcular a média ponderada dos elementos ,onde usa o nivel como peso !

[arfneto]

1 hora atrás, Anny Silva disse:

@arfneto  meu professor que passaa esses exercicios ,tenho um exercicio onde tem que criar uma  arvore binária e calcular a média ponderada dos elementos ,onde usa o nivel como peso !

 

Wow! Ao menos é coerente: nada a ver aquele uso da pilha, ou esse da fila ou o próximo com as árvores. Em geral se usaria uma árvore para percurso, representar estruturas, grafos, caminhos, dicionários.

 

Ele quer fugir do comum. E do útil. E da razão das estruturas de dados. Pode ser divertido. Útil não é.  

 

 

[arfneto]

De todo modo acho que deve programar as estruturas normalmente. E depois pode usar as 2 opções comuns:

• coloca na estrutura os valores que precisa para calcular as métricas, e mantem atualizado
• uma um algoritmo qualquer de percurso --- claro, isso não existe para pilhas --- e faz os cálculos. 

O enunciado exige manter a estrutura intacta depois do cálculo? 

[arfneto]

6 horas atrás, arfneto disse:

• coloca na estrutura os valores que precisa para calcular as métricas, e mantem atualizado
• uma um algoritmo qualquer de percurso --- claro, isso não existe para pilhas --- e faz os cálculos. 

 

Uma das duas opções, eu queria dizer. Ou acumula durante o uso ou extrai apenas quando pedido