C++ Contar os elementos de uma lista

[MadroxD]

Quero saber como faço para retornar na tela o numero total de elementos em uma fila, por exemplo: tenho uma fila dinamica que pelo meu codigo recebe 6 elementos, ela tem q me retornar

o numero de elementos para q eu possa trabalhar com ele no main

 

criei essa funcao que emprime os elementos:

void Listar(Item *cabeca)
{
	int i;
    if (EstaVazia(cabeca))
    {
        printf( " A lista esta vazia.\n\n" );
}
    else
    {
        while(cabeca != NULL)
        {
            printf("%i ", cabeca->numero);
            cabeca = cabeca->proximo;
            
        }
        
    }
}

 

[Mazze]

Olá, tudo bem?

funções do tipo void não podem retornar valores.

Pode me mandar o código completo para eu entender melhor? 

[KXSY]

@MadroxD você pode mudar o tipo da função para ela retornar um inteiro.

Aqui o seu código com um contador

void Listar(Item *cabeca)
{
	int i=0;
  if (EstaVazia(cabeca))
    printf( " A lista esta vazia.\n\n" );
  else
    while(cabeca != NULL)
    {
      printf("%i ", cabeca->numero);
      cabeca = cabeca->proximo;
      i++;
    }
  printf("\nO tamanho da lista e:%i",i);
}

 

[MadroxD]

@KXSY  obrigado pela atenção, eu acho q me expliquei mal, essa funcao "void" esta errada eu preciso trabalhar com o valor

no programa tem um while q trabalha enquanto ela tem mamanho, quando ela chegar a 1 elemento dentro da lista ela tem q para ou seja a ideia é executar ate ela ficar com 1 elemento

 

 

segue o codigo completo em anexo;

massadajudeu.rar

adicionado 2 minutos depois

@Mazze  Obrigado pela atenção, sim ele tem q passar para int porque vou precisar trabalhar com o valor

vou deixar o codigo aqui

 

#include <stdio.h>
#include <stdlib.h>

struct Item
{
    int numero;
    struct Item *proximo;
};

bool Inserir(Item **cabeca, int valor)
{
    Item *novo, *anterior, *atual;

    // -> Aloca memória para o novo item
    novo = (Item *)malloc(sizeof(Item));

    // -> Checa se foi alocado memória corretamente.
    if (novo != NULL)
    {    
        // -> Define e inicializa os valores.
        novo->numero = valor;
        novo->proximo = NULL;
        anterior = NULL;
        atual = *cabeca; // -> Atual é o ponteiro para o item da cabeça

        // -> Ordenação
        //    Verifica se a posição atual não é nula (início ou fim)
        //    Verifica se o valor é maior do que o número do item.
        while (atual != NULL && valor > atual->numero)
        {
            anterior = atual;           
            atual = atual->proximo;       
        }
        // -> Se não há posição anterior, então o novo item será a cabeça.
        if (anterior == NULL)
        {
            novo->proximo = *cabeca; // -> recebe o que já tem na cabeça.
            *cabeca = novo; // ->  cabeça nova.
        }
        else // -> Arranjando posição no meio da lista... Remanejando.
        {
            // -> Elemento anterior aponta para o novo.
            anterior->proximo = novo;
            // -> Novo elemento aponta para o resto da lista.
            novo->proximo = atual;
        }

        return true;
    }
    else   
    {
        return false;
    }
}   

bool Remover(Item **cabeca, int valor)
{
    Item *anterior, *atual, *itemRemover;

    anterior = NULL;
    atual = *cabeca;

    // -> Procura o valor.
    while(atual != NULL && atual->numero != valor)
    {
        anterior = atual;
        atual = atual->proximo;
    }
    // -> Quando encontra o valor.
    if(atual != NULL)
    {
        itemRemover = atual;

        if(anterior != NULL)
        {
            // -> Encurta o caminho.
            anterior->proximo = atual->proximo;
        }
        else // -> Quando o item é a cabeça.
        {
            // -> Ela recebe o próximo do primeiro item.
            *cabeca = (*cabeca)->proximo;
        }

        // -> Libera da memória o item excluído.
        free(itemRemover);

        return true;
    }

    return false;
}

bool EstaVazia(Item *cabeca)
{
    return cabeca == NULL;
}

void Listar(Item *cabeca)
{
    if (EstaVazia(cabeca))
    {
        printf( " A lista esta vazia.\n\n" );
    }
    else
    {
        printf( "Listando... \n");

        while(cabeca != NULL)
        {
            printf("%i ", cabeca->numero);
            cabeca = cabeca->proximo;
        }
    }
}

main()
{   
    Item *cabeca = NULL;
int i;
int m=6, p=1, n=2;

for(i=p; i<=m; i++){
	Inserir(&cabeca,i);
}

//while(Remover(&cabeca)!= 1){//numero de elementos dentro da lista
//	for(i=1; i<=6; i=i+n){//tem q andar pela lista de 2 em 2 eliminando os numeros em q ele cair
//		Remover(&cabeca,i-1);
//	}
//}
    
                Listar(cabeca);

                    
}

 

[KXSY]

1 hora atrás, MadroxD disse:

@KXSY  obrigado pela atenção, eu acho q me expliquei mal, essa funcao "void" esta errada eu preciso trabalhar com o valor

no programa tem um while q trabalha enquanto ela tem mamanho, quando ela chegar a 1 elemento dentro da lista ela tem q para ou seja a ideia é executar ate ela ficar com 1 elemento

É ainda não estou entendendo direito.

 

vou deixar o mínimo para criar uma lista encadeada.

/* Listas encadeadas */
#include <stdio.h>
#include <stdlib.h>


/* Tipos */
typedef struct Lista
{
  int numero;
  struct Lista *proximo;
}TLista;

void CriaNo(TLista **inicio, int numero);
void ApagaLista(TLista *inicio);

int main(void)
{
  TLista *inicio=NULL,*ponteiro;
  CriaNo(&inicio,1);
  CriaNo(&inicio,2);
  CriaNo(&inicio,3);
  CriaNo(&inicio,4);
  CriaNo(&inicio,5);
  ponteiro=inicio;
  while(ponteiro)
  {
    printf("\n%i",ponteiro->numero);
    ponteiro=ponteiro->proximo;
  }
  ApagaLista(inicio);
  return(0);
}

void CriaNo(TLista **inicio, int numero)
{
  if(!(*inicio))   /* Se inicio for igual a NULL */
  {
    /* Cria o primeiro nó na lista */
    *inicio=malloc(sizeof(TLista));
    if(!(*inicio))    /* Se inicio for igual a NULL */
      exit(EXIT_FAILURE);   /* Encerra o programa */
    (*inicio)->proximo=NULL;    /* Final da lista */
    (*inicio)->numero=numero;   /* Passa o numero para a lista */
  }
  else
  {
    /* Cria os outros nos na lista */
    TLista *temp=*inicio;
    /* Passa pela lista */
    while(temp->proximo)
      temp=temp->proximo;
    /* Cria um novo nó */
    temp=temp->proximo=malloc(sizeof(TLista));
    if(!temp)     /* Se temp for igual a NULL */
      exit(EXIT_FAILURE);   /* Encerra o programa */
    temp->proximo=NULL;
    temp->numero=numero;
  }
}

void ApagaLista(TLista *inicio)
{
  /* Pega o inicio da lista */
  TLista *temp=inicio;
  while(temp)
  {
    /* Guarda o proximo item da lista */
    inicio=temp->proximo;
    free(temp);   /* Apaga o item atual da lista */
    temp=inicio;    /* Pega o proximo item */
  }
}

 

[MadroxD]

@KXSY  entao mano, a função para adicionar na lista, remover da lista esta certo o unico problema é que eu preciso de uma função q possa me retornar um dado (quantos elementos tem na lista), porque a ideia é tipo de uma roleta russa, que vai eliminando os dados até que sobre 1 elemento. Então eu criei um  while(Remover(&cabeca)!= 1), ou seja enquanto tiver mais de um elemento ele vai ficar removendo e dentro do while eu coloquei um      for(i=1; i<=6; i=i+2){   Remover(&cabeca,i-1);  que é para remover de dois em dois: olha esse desenho para entender melhor

 

 

 

[arfneto]

Em C++ tem suporte a essas estruturas na STL. Não pode usar?

 

Crie uma classe para sua lista e acrescente uma variável com o total de itens em uso. Os itens não aparecem ou somem por acaso. Na função que inclui você soma, na que apaga você subtrai e sempre sabe quantos tem. Uma outra variável de sua classe Lista seria a própria origem da lista, e você passa o endereço da lista em todas as funções que vão usar a lista. Assim tudo funciona.

 

De todo modo, esses são os métodos da classe lista em C++ em http://www.cplusplus.com/reference/list/list/

Pode fazer igualzinho escrevendo só os métodos de que precisa... Mesmo que seja em C

 

[MadroxD]

@arfneto  não sei fazer desse jeito, mas obrigado

 

[arfneto]

26 minutos atrás, MadroxD disse:

não sei fazer desse jeito, mas obrigado

 

O que não entendeu? Explique e podemos ajudar.

 

Está usando C ou C++ ?

adicionado 1 minuto depois

"esse jeito" seria como marcar num papel o total de itens e o endereço de início da lista e ir passando para cada função que manipula a lista.

[MadroxD]

@arfneto  Estou usando C, inclusive vi agora que marquei tag errada ... enfim, estou aprendendo ainda a trabalhar com estrutura algumas coisa é como se fosse falar grego

não entendo porque ela não retorna o qtd

int Listar(Item *cabeca)
{
int qtd;	
    if (EstaVazia(cabeca)){
        printf( "Vazia\n" );
    }
    else{
        while(cabeca != NULL)
        {
            cabeca = cabeca->proximo;
            qtd++;    
        }   
    }
    return qtd++;   
}

 

[arfneto]

10 minutos atrás, MadroxD disse:

@arfneto  Estou usando C, inclusive vi agora que marquei tag errada ... enfim, estou aprendendo ainda a trabalhar com estrutura algumas coisa é como se fosse falar grego

não entendo porque ela não retorna o qtd

int Listar(Item *cabeca)
{
int qtd;	
    if (EstaVazia(cabeca)){
        printf( "Vazia\n" );
    }
    else{
        while(cabeca != NULL)
        {
            cabeca = cabeca->proximo;
            qtd++;    
        }   
    }
    return qtd++;   
}

 

 

Agora estamos nos comunicando...

 

Em C++ podia ser muito mais fácil ou podia ser igualzinho. Então vamos ficar com o lado igualzinho. 

Fica difícil sem ler o código todo e não li ainda. Imagino que tenha postado isso.

Pergunto:

• EstaVazia() funciona?
• Listar() esta retornando o que? ou dá erro?
• Está certo de que devia somar também no return?

Sobre "algumas coisa é como se fosse falar grego" se você não der exemplos vai ficar grego para mim  porque não vou saber de qual coisa está falando

adicionado 6 minutos depois

Vi que postou um arquivo no formato rar com o código. Sabe que pode postar o código aqui certo?

Se vai postar em algum formato comprimido sugiro usar zip ou pdf. Nesse caso o sistema de quem lê já tem suporte nativo para ler esse troço. Eu sei que eu posso instalar algo e que pode ser grátis e tal, mas não ajuda nada. Eu tenho que por exemplo abrir a loja instalar um programa de que não preciso, fazer um download, extrair seu código e carregar num editor... 

[MadroxD]

@arfneto  

EstaVazia() funciona?

sim

 

Listar() esta retornando o que? ou dá erro?

não esta retornando nada, se eu colocar um printf('%d", cabeca->proximo;) no while ela vai imprimir todos os elementos q eu digitei

 

Está certo de que devia somar também no return?

não eu ja corrigi

 

o objetivo da funcao Listar() é apenas contar os elementos da lista 

[arfneto]

14 minutos atrás, MadroxD disse:

o objetivo da funcao Listar() é apenas contar os elementos da lista 

 

Entendo. Se tivesse uma rotina pra listar ia chamar como?

 

Posta o resto do código e mais tarde eu dou uma olhada e rodo ele aqui.

[MadroxD]

@arfneto  mandei o codigo completo, obrigado pela atenção esta ajudando muito !

massadajudeu.pdf

[arfneto]

3 horas atrás, MadroxD disse:

@arfneto  mandei o codigo completo, obrigado pela atenção esta ajudando muito !

massadajudeu.pdf 2 kB · 0 downloads

 

Meu computador diz que tem algo errado com o pdf. Pode usar o icone <> aqui na tela mesmo e colar seu programa na janela que vai abrir. Ou usar um zip que assim fica fácil de extrair em windows ou linux. Ou mesmo um .txt anexado ao post acho que o forum aceita.

adicionado 6 minutos depois

Minha sugestão de sempre para meu pessoal e aqui de novo: ao implementar qualquer estrutura de dados tipo container:

• primeiro implementa a função que lista. Lista mesmo, um por um na console ou numa caixa de texto sem mais. E chama com a lista vazia
• depois a função que insere para colocar um
• usa a função que lista ainda quando só tem um
• insere outro
• a função que lista quando tem dois
• a função que apaga e a função que lista, uma depois da outra até ficar vazio
• insere dois
• insere no fim e lista
• insere no meio e lista
• insere no inicio

Assim cobre as situações comuns com alguma segurança e testando a cada passo

[Mazze]

@MadroxD ja tentou tirar o ++ do qtd no return?

[arfneto]

E aí? sucesso com o código?

 

Como eu disse em outro tópico sobre o mesmo problema, lista não é nem de longe uma boa estrutura para esse problema.

De qualquer forma se você insistir nisso uma declaração como a que segue resolveria seu problema. O nsu é um número de sequência para os elementos da lista para ajudar a testar. Se some algum igual fica fácil saber qual foi e também fica fácil saber em que ordem insere os iguais. No seu caso acho que não tem nem essa possibilidade de duplicatas. Mas eu precisava de algo mais genérico. Obviamente cada lista tem uma variável elementos que marca quantos tem a cada momento. Com essa implementação pode ter várias listas no mesmo programa, independentes. Precisa de um exemplo?

 

#pragma once
#include <stdio.h>
#include <stdlib.h>

struct item
{
    int            valor; // o item em si
    int            serial; // o numero unico na lista
    struct item*   anterior;
    struct item*   proximo;
};
typedef struct item Item;

struct lista
{
    int             elementos; // o contador
    int             nsu; // numero sequencial unico
    char*           nome; // nome da lista
    Item*           origem; // endereço de inicio
};
typedef struct lista Lista;

Mas não precisa disso. Dá pra resolver em uma função só eu creio.

adicionado 2 minutos depois

 

 

[arfneto]

Vi um certo número de soluções on-line para esse problema.
 

Esse site em particular tem um código escrito por Carlos Fleitas que permite animar o problema e testar com vários parâmetros. Nada mal para testar suas funções. Ou as minhas Circulo de Josephus online app

 

E nesse aqui https://www.urionlinejudge.com.br/repository/UOJ_1030.html tem uma explicação bem razoável do problema, em português.

 

E vi mesmo muitas tentativas que resolver usando listas e tal. Vou deixar duas soluções que eu escrevi e acho mais simples

 

Solução 1

int resolve_para(int M, int N, int P);

Você passa M N e P e recebe a posição do sobrevivente. Usei a posição partir de zero. Eis a função completa

int resolve_para(int M, int N, int P)
{
	int  pos = P, vivos = M;
	int* circulo = (int*)malloc(sizeof(int) * M);
	printf("M=%d, N=%d, P=%d\n", M, N, P);
	for (int i = 0; i < M; i += 1) circulo[i] = 1; // vivo

	while (vivos > 1)
	{
		for (int avanco = 0; avanco < N; avanco = circulo[pos]== 1 ? avanco+1 : avanco )
			pos = (pos + 1) % M; // conta so os vivos
		circulo[pos] = 0; // morre aqui o pos
		vivos = vivos - 1;
	};	// while

	for (pos = 0; pos < M; pos += 1)
	{
		if (circulo[pos] == 1 )
		{	// retorna o sobrevivente ou -1
			free(circulo); // apaga o vetor
			return pos; // comeca de zero
		};
	}   // for
};	// resolve_para()

Como vê, dá pra resolver com uma única função e uma única estrutura de dados: o vetor

 

Solução 2

int resolve_para(int M, int N, int P, int vivos, int* circulo)

É a mesma coisa. Minha ideia aqui era que nada muda exceto para o infeliz que morreu a cada rodada. Então basta rodar uma vez e se tem mais de um vivo chamar a função de novo com a nova posição e um cara a menos. Só que precisa passar o vetor com M caras preenchido com 1 para simplificar a recursão

int resolve_para(int M, int N, int P, int vivos, int* circulo) {
	int pos = P;
	if (vivos < 2) {
		for (pos = 0; pos < M; pos = pos + 1) if (circulo[pos] == 1) break;
		return pos;
	}
	for (int avanco = 0; avanco < N; avanco = circulo[pos] == 1 ? avanco + 1 : avanco) pos = (pos + 1) % M; 
	circulo[pos] = 0; // morre aqui o pos
	resolve_para(M, N, pos, vivos - 1, circulo);
};	// resolve_para()

Apenas 10 linhas. 

 

Se precisar posso postar uma explicação de porque as duas funcionam. Estou perdendo a paciência com esse editor do forum  : demora mais tempo para formatar o texto do que para escrever uma solução, às vezes...

 

Procurei escrever sem grandes invenções e usando nomes óbvios ou que já estavam no enunciado.

Espero que ajude a entender porque eu disse que aquele caminho com as listas era uma ideia ruim