Ir ao conteúdo
  • Cadastre-se
Wellisson Bastos

C Algoritmo sobre listas encadeadas!

Recommended Posts

Olá pessoal, gostaria de uma ajuda em um algoritmo. Não consigo pegar o conteúdo da cadeira de Estrutura de Dados. A professora nos mandou um esqueleto de uma estrutura:

/* ================================================= */
/* Exemplo de implementacao Listas Simplesmente Enc. */
/* Exercicios da apostila                            */
/* Profa Fabiana Lorenzi                             */
/* Estruturas de Dados I                             */
/* ================================================= */

#include <stdio.h>
#include <conio.h>
#include <malloc.h>

/* estrutura da Lista Simplesmente Encadeada...*/
struct nodo {
int dados;
struct nodo *proximo;
};

void insere_esquerda(struct nodo **inicio, struct nodo **fim, int valor, int *sinal);
void insere_antes_de_k (struct nodo **inicio, struct nodo *k, int valor , int *sinal);


/* ==================================== */
/* Insere um nodo a esquerda (no inicio)*/
/* ==================================== */
void insere_esquerda(struct nodo **inicio, struct nodo **fim, int valor, int *sinal)
{
  struct nodo *p;

     p = (struct nodo *) malloc (sizeof(struct nodo));
     if (p)
     {
    p->dados=valor;
    p->proximo=*inicio;
    *inicio = p;
    if (*fim==NULL)
       *fim = p;
        *sinal=1;
     }
     else
*sinal=0;
}

/* =============================== */
/* Insere um nodo antes do nodo K; */
/* =============================== */
void insere_antes_de_k (struct nodo **inicio, struct nodo *k, int valor , int *sinal)
{
  struct nodo *ant, *aux, *p;
  
  if (*inicio) //Se a lista n�o est� vazia
  {   p= (struct nodo *) malloc (sizeof(struct nodo));
  if (p == NULL)     //Se n�o foi poss�vel alocar espa�o em mem�ria
             *sinal = 0;
          else
          {
        p->dados = valor;
            aux = *inicio;
            while (aux != k && aux != NULL)  //Percorre a lista at� achar o nodo k  ou at� chegar ao fim da lista.
    {   ant = aux;
        aux = aux->proximo;
            }
            if (aux != NULL)
            {
           if (k==*inicio)
               {
            p->proximo=*inicio;
         *inicio=p;
                 *sinal = 1;
       }
               else
       {
         ant->proximo = p;
           p->proximo = k;
         *sinal = 1;
              }
        }
            else   //n�o encontrou k
    {  *sinal= 0;
       free(p);
           }
           }  //se reservou memoria para p
   } else
*sinal= 0;  //nao existe lista
}

/* ====================================================================== */
/* funcao que conta quantos elementos tem a lista simplesmente encadeada. */
/* ====================================================================== */
int conta (struct nodo *lista)
{
  int cont=0;

  while (lista != NULL)
  {
      cont = cont+1;
      lista=lista->proximo;
  }
  return cont;
}

/* ====================================================================== */
/* funcao que retorna o nodo com maior elemento da lista simp. encadeada. */
/* ====================================================================== */
struct nodo *maior_valor (struct nodo *lista)
{
  int ma=0;
  struct nodo *p, *ant;

  if (lista == NULL)
  {
    p=NULL;
  }
  else
  {
     ma=lista->dados;
     p=lista; /* guarda o end. do nodo, caso o maior seja o 1o. nodo da lista */
     ant=lista;
     lista=lista->proximo;
     while (lista != NULL)
     {
   if (lista->dados > ma) /* procura o maior valor da lista... */
       {
     ma = lista->dados; /* guarda o valor em MA */
       p = ant->proximo;  /* guarda o endereco do maior valor em P */
       }
       ant=lista;
       lista=lista->proximo;
     }
  }
  return p; /* funcao sempre retorna valor. */
}

/* =============================================== */
/* Procedimento para mostrar o conteudo da lista.  */
/* =============================================== */
void mostra_lista (struct nodo *lista)
{
  struct nodo *aux;

  aux=lista;
  while (aux != NULL) /* Enquanto nao for final da lista... */
  {
    printf("Valores-> %i\n",aux->dados);
    aux=aux->proximo;
  }
}

/* =============================================== */
/* Procedimento que libera todo conteudo da lista  */
/* =============================================== */
void libera_lista (struct nodo **lista)
{
  struct nodo *aux, *p;

  aux=*lista;
  while (aux != NULL) /* Enquanto nao for final da lista... */
  {
    p=aux;
    aux=aux->proximo;
    free(p);
  }
}


/* Programa principal */
int main()
{
  int num, ok;  // variavel global que representa o sinal

  struct nodo *l1i=NULL, *l1f=NULL, *lk=NULL;

  // l1i = inicio da lista
  // l1f = final da lista
  // lk = lista que armazena o endereco do nodo K

  /* Este trecho do programa serve para que o usuario digite varios valores (ate digitar 0)
     que serao armazenados na lista (insercao no inicio da lista).
  */
  printf("\nPara encerrar a insercao digite 0 !");
  do {
       printf("\nInforme um valor. : ");
       scanf("%d",&num);
       if (num != 0)
       {
      insere_esquerda(&l1i, &l1f, num, &ok);
         if (ok == 0)
           printf("\nErro de alocacao de memoria...");
       }
     }
  while (num != 0);

  /* O procedimento mostra_lista serve para mostrar o conteudo da lista
     que est? sendo passada como parametro.
  */
  mostra_lista(l1i);
  getch();

  /* Este trecho do programa serve para que o valor digitado pelo usuario seja
     inserido ANTES do nodo que tem o maior valor.
  */
  printf("\nInforme outro valor: (insercao antes o maior elemento da lista(K)): ");
  scanf("%d",&num);
  if (num != 0)
  {
   /* a vari?vel global lk representa o K.
      a funcao maior_valor ? chamada e o endereco do nodo com o maior valor ?
      armazenado na variavel global lk (K).
   */
   lk=maior_valor(l1i);

   /* Chamada do procedimento Insere_antes_de_k
      =========================================
     Neste exemplo, o valor digitado pelo usuario sera incluido antes do nodo que tem
     o maior valor (ou seja, a posicao K eh a posicao do nodo que armazena o maior valor
     da lista.
   */
   insere_antes_de_k(&l1i, lk, num, &ok);
   if (ok == 0)       // se deu erro de alocacao de memoria...
     printf("\nErro de alocacao de memoria...");
    
   mostra_lista(l1i);
   getch();
   libera_lista(&l1i);
   getch();
  }
}

E pediu para que nós fizemos o seguinte:

Questão 1 - Escreva um procedimento para inserir um valor de forma ordenada em uma lista simplesmente encadeada (sem header).

Questão 2 - Escreva um procedimento que remove os valores repetidos de uma lista simplesmente encadeada (sem header).

 

Mas estou com mt dificuldade, desde já agradeço a ajuda.
 

Editado por Simon Viegas
Inserir tag CODE

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×