C Como o usuário inserir os valores - Lista simples encadeada

[PaulaFabiana]

Minha dúvida é como mostrar todos os dados inseridos, preciso fazer um trabalho em que o usuário insere os números e imprime o que ele inseriu, o problema é que esta mostrando apenas a primeira valor, os outros não,

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


typedef struct Lista
{
    int elemento;
    struct Lista *prox;


} celula;

void insereH(celula **topo, int elem)
{
    celula *novo;
    novo= malloc(sizeof(celula));
    novo->elemento= elem;
    if(*topo==NULL)
    {
        novo-> prox=NULL;
        *topo= novo;
    }
}

void Imprimir_tela(celula *topo)
{
    celula *aux;
    aux= topo;
    if(aux==NULL)
    {

    }
    else
    {
        do
        {
            printf("%d",aux-> elemento);
            aux= aux->prox;
        }
        while(aux!=NULL);
    }
}
main()
{

    celula *topo= NULL;
    int x;
    int cont=0;
    do{
    printf("Digite um valor para inserir ou 0 para sair: ");
    scanf("%d", &x);
        insereH(&topo, x);
    cont++;
    }while(x!=0);
    printf("Quantidade de numeros inseridos: %d\n\n", (cont-1));

    Imprimir_tela(topo);

}

sabe como fazer, não sei mexer muito com ponteiro, muito menos com listas 

[Visitante]

@PaulaFabiana  Olá. Vou pelo menos procurar ajudar de algum modo passando um exemplo muito didático com relação a como trabalhar com lista encadeada. Não estou apontando a solução para seu exercício, mas creio q com esse exemplo, você vai poder entender de o por quê de ser impresso apenas um número. Espero q com esse código eu possa ajudar um pouco

 

// ProjetoListaEncadeada.cpp : define o ponto de entrada para o aplicativo do console.
//

#include "stdio.h"
#include "stdlib.h"

struct elemento
{
    int valor;
    struct elemento *proximo;
};


void listaEncadeadaLigacao(struct elemento *origem, struct elemento *destino)
{
	if (origem->proximo == NULL)
	{
	    origem->proximo = destino;
	    destino->proximo = NULL;
	}
	else
	{
	    destino->proximo = origem->proximo;
	    origem->proximo = destino;
	}
}


void imprimeListaEncadeada(struct elemento *origem)
{
	printf("\n ");

	do
	{
	    printf("%d ", origem->valor);
	    origem = origem->proximo;
	} while (origem != NULL);
}


int main()
{
    char *c = NULL;

    struct elemento e1, e2, e3, e4, e5, e6;

    e1.valor = 1;
    e1.proximo = NULL;

    e2.valor = 2;
    e2.proximo = NULL;

    e3.valor = 3;
    e3.proximo = NULL;

    e4.valor = 4;
    e4.proximo = NULL;

    e5.valor = 5;
    e5.proximo = NULL;

    e6.valor = 6;
    e6.proximo = NULL;

    imprimeListaEncadeada(&e1);

    listaEncadeadaLigacao(&e1, &e2);
    listaEncadeadaLigacao(&e2, &e3);
    listaEncadeadaLigacao(&e3, &e4);
    listaEncadeadaLigacao(&e4, &e5);

    imprimeListaEncadeada(&e1);

    listaEncadeadaLigacao(&e3, &e6);

    imprimeListaEncadeada(&e1);

    scanf("%c", &c); // Para segurar a tela aberta no Visual Studio

    return 0;
}

Dá uma olhada para ver se ajuda. Devo confessar q preciso revisar essa questão de lista encadeada

adicionado 3 minutos depois

Desconsidere as duas primeiras linhas comentadas no início do código. Isso é algo que é gerado pelo Visual Studio.

Para um código como esse, em C, a extensão do arquivo é .c e não .cpp

[PaulaFabiana]

@giu_d Olá, sim me ajudou muito, obrigado

[Visitante]

@PaulaFabiana Legal! Fico feliz em poder ter ajudado d alguma forma. Gostaria de dar uma ajuda mais objetiva mas, como disse, preciso revisar o assunto sobre lista encadeada

[PaulaFabiana]

@giu_d Isso ja me ajudou muito, obrigado

[Visitante]

@PaulaFabiana Valeu! Fico feliz por isso

[Simon Viegas]

@giu_d, ajustei o seu código e fiz funcionar, apenas está criando a lista em ordem inversa (segue a estrutura original).

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

typedef struct Lista {
    int elemento;
    struct Lista *prox;
} celula;

void insereH(celula **topo, int elem) {
    celula *novo;
    //novo = malloc(sizeof(celula));  <---aqui no Dev++ 5.11 não funcionou [Simon.Viegas]
    novo = (celula*)malloc(sizeof(celula));
    novo->elemento = elem; 
    novo->prox = NULL; //o novo aponta para nada [Simon.Viegas]
    if (*topo==NULL) { //se primeira célula [Simon.Viegas]
        *topo = novo;  //topo aponta para o novo [Simon.Viegas]
    } else {
	   novo -> prox = *topo;
	   *topo = novo;
	}
}

void Imprimir_tela(celula *topo) {
    celula *aux;
    aux = topo;
    //if (aux==NULL) { //a variável acbou de ser criada! A não ser que queira verificar se criou, mas entraria outros ponto[Simon.Vieagas]
    if (topo == NULL ) { 
        printf("Lista vazia");
    } else {
        do {
            printf("%d",aux->elemento);
            aux=aux->prox;
        } while(aux!=NULL);
    }
}
main() {
    celula *topo=NULL; //inicializa a celula (faz apontar para nada)
    int x;
    int cont=0;
    do {
        printf("Digite um valor para inserir ou 0 para sair: ");
        scanf("%d", &x);
        if (x!=0) { //para não adicionar o 0 [Simon.Viegas]
            insereH(&topo, x);
            cont++;
        }
    } while (x!=0);
    printf("Quantidade de numeros inseridos: %d\n\n", (cont-1));
    Imprimir_tela(topo);
}

 

Nas "listas" não existem regras de ordem (diferente de pilhas e filas), mas é mais sensato exibir na ordem de inserção.

Vou dar uma pesquisada, se encontrar eu posto... mas fica tb a sugestão para vocês.

 

 

No aguardo.

[PaulaFabiana]

A pergunta: Implemente os algoritmos de busca sequencial e binária (pesquisa e inserção) para listas simplesmente encadeadas.

Enfim eu consegui, fazer para busca sequencial e resolve o problema com a tela, obrigado pessoal, agora vou tentar com busca binaria(Mas esta difícil)
 

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

typedef struct celulaLista
{
    int informacao;
    struct celulaLista *proximo;
} celula;
static int cont=0;

int PesquisaSequencial(celula* head, int x);


int main()
{
    celula *pLista;
    int opcao = 0;
    void initLista(celula **pRecebido);
    void insertLista(celula **pRecebido);
    void MostrarTela(celula **pRecebido);


    int leValor(int *valorRecebido);
    pLista = (celula *)malloc(sizeof(struct celulaLista));
    initLista(&pLista);
    int x;
    do
    {
        printf("Digite 1 para inserir valor ou 0 para sair: ");
        scanf("%d", &x);
        if(x==1)
        {
            cont++;
            insertLista(&pLista);
        }
    }
    while(x!=0);
    printf("----VALORES---\n");
    MostrarTela(&pLista);
    printf("Quantidade de numeros inseridos: %d\n\n", cont);
    printf("Digite o valor para ser buscado: ");
    int numero;
    scanf("%d", &numero);
    printf(" A Posicao eh :%d\n", PesquisaSequencial(pLista, numero ));

    return 0;
}

void initLista(celula **pRecebido)
{
    (*pRecebido)->proximo = NULL;
}

void insertLista(celula **pRecebido)
{
    celula *temporario;
    int valor;
    printf("\nInforme um Valor a ser Inserido : ");
    scanf("%d", &valor);
    temporario = (celula *)malloc(sizeof(celula));
    temporario->informacao = valor;
    temporario->proximo = (*pRecebido)->proximo;
    (*pRecebido)->proximo = temporario;
}

void MostrarTela(celula **pRecebido)
{
    celula *temporario;
    if((*pRecebido)->proximo == NULL)
    {
        printf("Lista Vazia!\n");
    }
    else
    {
        temporario = (celula *)malloc(sizeof(celula));
        temporario = (*pRecebido)->proximo;
        while(temporario != NULL)
        {

            printf("Valor : %d\n", temporario->informacao);
            temporario = temporario->proximo;
        }
    }
}
///////////////////////////////////
int PesquisaSequencial(celula* head, int x)
{
    int nodeNum = 0;
    while(head != NULL)
    {
        if(head->informacao == x)
            return nodeNum;
        nodeNum++;
        head = head->proximo;
    }
    return -1;
}

 

[Plástico Bolha]

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

typedef struct NO {
    NO* next;
    float data;
} NO;

typedef struct _list{
    NO* First; 
    NO* Last;
} _list;

_list *create(){  
    _list *l = (_list*) malloc(sizeof(_list));
    l->First = NULL;
    l->Last = NULL;
    return l;
}

void insert(_list *l){ 
    float data;
    do {
        printf("Digite o dado: ");
        scanf("%f", &data);
        if(data < 0) break;
        NO* R=(NO*) malloc(sizeof(NO));
        if(l->First == NULL) {
            R->next =NULL;
            l->Last = R;
            l->First = R;
            R->data = data;
        } else {
            NO* j;
            NO *aux;
            j = l->First;
            while(j != NULL){
                aux = j;
                j = j->next;
            }
            j = aux;
            j->next = R;
            R->data = data;
            R->next = NULL;
            l->Last = R;
        }
    } while(data > 0);
}

void printfList(_list *l) {
    NO* j;
    j = l->First;
    printf("\nDados armazenados na lista\n");
    while(j != NULL){
        printf("Elemento da lista: %.0f\n", j->data);
        j = j->next;
    }
}

void main(){
      _list *l = create();
      printf("OBS: Para sair da funcao digite um numero negativo\n");
      insert(l);
      printfList(l);
      printf("\n");
      system("PAUSE");
}

 

[Simon Viegas]

2 horas atrás, PaulaFabiana disse:

printf("Digite 1 para inserir valor ou 0 para sair: ");

Ficar perguntando toda hora achei ruim... melhor como estava antes.

[Visitante]

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


typedef struct Lista
{
    int elemento;
    struct Lista *prox;
} celula;


celula *destino = NULL, *aux = NULL;


void insereH(int elem)
{
    celula *novo = NULL;

    novo = (celula*) malloc(sizeof(celula));

    novo->elemento = elem;

    if (destino == NULL)
    {
        destino = novo;
        novo->prox = destino;
        destino->prox = novo;
    }
    else
    {
        aux = destino;
        while(aux->prox != destino)
        {
            aux = aux->prox;
        }
        novo->prox = destino;
        aux->prox = novo;
    }
}


void Imprimir_tela()
{
    aux = NULL;

    if (destino != NULL)
    {
        aux = destino;
        printf("Numeros inseridos: ");
        do
        {
            printf("%d ", aux->elemento);

            aux = aux->prox;

        } while (aux != destino);
    }
    else
    {
        printf("A lista esta vazia!");
    }
    printf("\n");
}


int main()
{
    int x;
    int cont = 0;
    do {
        printf("Digite um valor para inserir ou 0 para sair: ");
        scanf("%d", &x);
        fflush(stdin);
        if (x != 0)
        {
            insereH(x);
            cont++;
        }
    } while (x != 0);

    printf("\nQuantidade de numeros inseridos: %d\n\n", cont);

    Imprimir_tela();

    return 0;
}

 

[Visitante]

@PaulaFabiana  Olá. Devido a dificuldade q percebi ter com relação a trabalhar com lista encadeada resolvi entrar em contato com meu instrutor de C, e, além de uma breve explicação, também me orientou a revisar as aulas do curso e também me passou uma material muito bom. Esse material você pode conseguir aqui:

http://www.ic.unicamp.br/~ra069320/PED/MC102/1s2008/Apostilas/Cap10.pdf

Pelo pouco q estudei com esse material, já pude entender muita coisa q não estava clara com relação a lista encadeada.

Por ex: No primeiro exercício q você postou e q depois foi em partes ajustado pelo @Simon Viegas  o problema q está ocorrendo é q os valores estão sendo inseridos no início da lista. Por isso a impressão desses valores não segue a ordem de inserção. O correto seria inserir os elementos no fim da lista. Isso resolve q questão de imprimir de acordo com ordem de inserção.

Mas, a princípio, dando uma breve olhada no material q passei acima, já deu para fazer um exercício bem simples, mas claro, inda continua a questão de inserção no início da lista. 

Mas a meta com esse exercício q vou passar é a didática. Realmente estou aprendendo com esse material.

As explicações mais detalhadas sobre as funções q uso no código você consegue acessando esse material.

Na verdade o código q vou postar aprendi a fazer devida a explicação dada no mesmo

Segue o código. Ficou algo relativamente simples e com uma boa didática:

 

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

struct lista
{
    int info;
    struct lista *prox;
};

typedef struct lista Lista;

/* função de inicialização: retorna uma lista vazia */
Lista *inicializa() {

    return NULL; // retorna uma lista vazia
}

/* inserção no início: retorna a lista atualizada */
Lista* insere(Lista* l, int i) {

    Lista *novo = (Lista *) malloc(sizeof(Lista));

    novo->info = i;
    novo->prox = l;

    return novo;
}

/* função imprime: imprime valores dos elementos */
void imprime(Lista* l) {

    Lista *p = l;

    do {
        printf("Info: %2d\n", p->info);
        p = p->prox;
    } while (p != NULL);
}


void libera(Lista* l) {

    Lista *p = l;

    while (p != NULL) {
        Lista *t = p->prox; /* guarda referência para o próximo elemento */
        free(p); /* libera a memória apontada por p */
        p = t; /* faz p apontar para o próximo */
    }
}


int main() {

    Lista *l;

    l = inicializa(); // inicializa a lista

    int cont = 0, x;

    do {
        printf("Digite o numero para inserir ou 0 para sair: ");
        scanf("%d", &x);
        fflush(stdin);
        if (x != 0) {
            l = insere(l, x);
            cont++;
        }
    } while (x != 0);

    printf("\nQuantidade de numeros inseridos: %d\n\n", cont);

    imprime(l);

    libera(l);

    return 0;
}

Se deu para ajudar mais um pouco maravilha. Devido a esse tópico foi q eu me dei conta dessa minha dificuldade e agora o negócio é estudar sobre o assunto! 

[PaulaFabiana]

@giu_d Poxa obrigada, pela explicação e por se dar o trabalho de procurar o conteúdo, vou ler o material, obrigado Giu