C função que receba como parâmetro um ponteiro para uma lista

Gabriela_0587 · 11 de setembro de 2019

Alguém pode me ajudar com esse programa em C ?

Considere o código abaixo de Lista Duplamente Encadeada. Crie uma função que receba como parâmetro um ponteiro para uma lista e retorne o número de elementos desta lista. Para isto, será necessário percorrer toda a lista e incrementar um contador.

Em seguida, implemente na main uma função que insere os elementos na lista e exiba a quantidade de elementos (usando a função criada).

<

struct NO{

    int elemento;

    struct NO *prox;

    struct NO *ant;

} ;



typedef struct {

    struct NO *inicio;

} LISTA;



void init(LISTA *ls) {

    ls->inicio = NULL;

}



int empty(LISTA *ls)    {

    if (ls->inicio == NULL)

        return 1;

    else

        return 0;

}

void insert(LISTA *ls, int elemento) {

    struct NO *novo = (struct NO*) malloc(sizeof(struct NO));

    if (ls->inicio != NULL) {

        ls->inicio->ant = novo;

    }

    novo->elemento = elemento;

    novo->prox = ls->inicio;

    novo->ant = NULL;

    ls->inicio=novo;

}

>

KXSY · 11 de setembro de 2019

você sabe pelo menos fazer uma lista simplesmente encadeada?

Exemplo básico

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


/* tipos */
typedef struct Lista
{
  int dados;
  struct Lista *proximo;
}TLista;


int main()
{
  TLista *inicio=NULL,*ponteiro=NULL;
  int temporario;
  char tecla;
  /* Loop principal */
  do
  {
    /* Pega um numero do usuario */
    printf("\nDigite um numero:\t");
    scanf("%i",&temporario);
    getchar();
    /* Coloca o primero elemento fila */
    if(!inicio)
    {
      inicio=malloc(sizeof(TLista));
      /* Encerra o programa se não tiver memoria disponivel */
      if(!inicio)
      {
        perror("\nNao ha memoria disponivel.");
        return(-1);
      }
      inicio->proximo=NULL;   /* Define o final da lista */
      inicio->dados=temporario;   /* Passa os dados para a lista */
      ponteiro=inicio;    /* Garante que o programa vai funcionar na proxíma interação */
    }
    /* Coloca os elementos seguintes */
    else
    {
      ponteiro->proximo=malloc(sizeof(TLista));
      /* Encerra o programa se não tiver memoria disponivel */
      if(!ponteiro->proximo)
      {
        perror("Nao ha memoria disponivel.");
        return(-1);
      }
      ponteiro=ponteiro->proximo;
      ponteiro->proximo=NULL;
      ponteiro->dados=temporario;
    }
    /* Pergunta se o usuario quer sair do loop principal */
    printf("\nDeseja sair S/N:\t");
    scanf("%c",&tecla);
    getchar();
  }while(tecla!='s');
  /* Mostra os numeros */
  ponteiro=inicio;    /* Aponta para o inicio da fila */
  printf("\nOs numeros digitados foram\n");
  while(ponteiro)
  {
    printf("\n%i",ponteiro->dados);
    ponteiro=ponteiro->proximo;
  }
  /* Apaga a lista */
  ponteiro=inicio;
  while(ponteiro)
  {
    inicio=ponteiro->proximo;
    free(ponteiro);
    ponteiro=inicio;
  }
  return(0);
}

Se a resposta for não, então e bom começar por ai!

arfneto · 12 de setembro de 2019

Olá Gabriela

Vendo como está escrito lá:

você já tem as funções empty(), init() e insert() com propósitos óbvios

você precisa escrever duas outras que vamos chamar de tamanho_da_lista() e insere_mais_na_lista() por exemplo
não faz diferença se a lista é duplamente encadeada ou qualquer coisa, já que a função insert() foi fornecida

Vamos ver as funções: elas tem nome, argumentos e valor de retorno

tamanho_da_lista():

retorno: seria bem conveniente essa função retornar o tamanho da lista, não dá nem pra discutir. um int está ok. Retornar -1 se der erro é uma boa prática
argumentos: o endereço da lista, certo? ou não vai adiantar de nada.

então

int tamanho_da_lista( LISTA* lista);

está ok.

insere_mais_na_lista():

retorno: seria conveniente retornar o novo tamanho da lista, claro.
argumentos: precisamos do óbvio endereço da lista e dos elementos a inserir. Potencialmente mais de um porque o enunciado diz "insere os elementos", plural. Então temos dois argumentos: o total de elementos a inserir e os elementos a inserir. Nossa LISTA é uma lista de (int) então esses serão os argumentos. Então:

int insere_mais_na_lista( LISTA* lista, int a_inserir, int* valores);

Mas dá pra acreditar sem ver?

precisamos de uma função para mostrar o que tem na lista, que pode ser assim

int mostra(LISTA* p);

para poder conferir...

Vou mostrar aqui uma maneira de escrever isso só porque me dei ao trabalho de escrever e porque acho que o modo de ler os requerimentos e escrever as funções pode ser útil a outros aqui. Escrever uma solução apenas para alguém copiar e colar não seria útil para ninguém...

Então...

Temos que partir do princípio que já temos código funcionando! As funções providas são essenciais.

main()

Eis uma possível main() pra testar essas funções, bem normal. No final chama a função mostra() para a gente poder conferir

int main(int argc, char** argv)
{
    LISTA    nova;
    LISTA*    pLista = &nova;
    int    v[6] = { 6, 5, 4, 3, 2, 1 };
    int    r;  

    init( pLista );
    r = insere_mais_na_lista(pLista, 6, v);
    r = tamanho_da_lista(pLista);
    printf("Tamanho da lista depois de inserir os 6 [%d] (deve ser 6 claro)\n", r);
    printf("\nAgora mostra a lista: deve ter (1 2 3 4 5 6) ja que insere sempre no inicio\n");
    mostra(pLista);
    return 0;
}

E mostra isso

Tamanho da lista depois de inserir os 6 [6] (deve ser 6 claro)
Agora mostra a lista: deve ter (1 2 3 4 5 6) ja que insere sempre no inicio

mostrando os elementos da lista
1: [1]
2: [2]
3: [3]
4: [4]
5: [5]
6: [6]

E as funções?

computar o tamanho da lista é simples: pega um ponteiro para o inicio e vai contando os caras. Se não tiver nenhum retorna 0. Quando achar o último --- dava pra imaginar -- é porque terminou e aí retorna o total percorrido. Como essa:

int tamanho_da_lista(LISTA* lista)
{
    // verifica os ponteiros antes
    if (lista == NULL) return -1;
    int n = 0;
    struct NO* ponteiro = lista->inicio;
    while( ponteiro != NULL )
    {
        n += 1;
        ponteiro = ponteiro->prox;
    } 
    return n;
}    // end tamanho_da_lista()

E inserir os caras? Trivial, porque já tem o código que insere e o resto vem nos parâmetros. Então basta seguir a lista de parâmetros e inserir os valores. Exemplo:

int insere_mais_na_lista(LISTA* lista, int a_inserir, int* valores)
{
    for (int i = 0; i < a_inserir; i++)
    {
        insert(lista, valores[i]);
    }
}    // end insere_mais_na_lista()

E mostrar() é igual a ver o tamanho só que ao invés de contar os elementos a gente mostra na tela: podemos usar o mesmo código. E como eu numerei os elementos para mostrar não custa nada retornar o tamanho também. Eis um exemplo:

int mostra(LISTA* p)
{
    if (p == NULL) return -1;
    if (p->inicio == NULL) return -2;
    struct NO* ponteiro = p->inicio;
    int n = 1;
    printf("\nmostrando os elementos da lista\n");
    do
    {
        printf("%d: [%d]\n", n, ponteiro->elemento);
        n += 1;
        ponteiro = ponteiro->prox;
    } while (ponteiro != NULL);
    return (n-1);
}

É isso. Espero que ajude.

O programa inteiro de teste está aqui no site e tem um botão de download verde enorme