ajuda com lista encadeada

[Eliza21]

- Olá, pessoal, tentei hoje o dia inteiro resolver esse problema que foi proposto por meu professor, gostaria que se possível alguém me ajude com a implementação...

==================================================================================

Tarefa:

Construa um programa para executar as operações básicas sobre uma lista linear encadeada implementada sobre um arranjo (simulação de lista encadeada) conforme segue:

• Varias lista são implementadas sobre o mesmo arranjo, logo deve haver uma opção no menu do programa principal para permitir que o usuário defina o espaço do arranjo que será utilizado pela lista.

• Definir uma opção do menu para cada operação básica sobre lista, conforme visto em sala de aula, ou seja: criação de lista vazia, inserção(no inicio, no fim ou entre nodos), consulta, remoção e destruição da lista.

• Opção no menu para listar o conteúdo da lista e também uma opção para listar as posições livres dentro do espaço reservado para a lista.

• Nas operações de consulta e remoção o usuário deve fornecer a ordem do nodo da lista que será consultado/removido.

• O menu deve ser construído de forma que o usuário possa escolher livremente a ordem de execução das operações.

==================================================================================

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

#define nulo -1   //indicativo de valor nulo
#define QTNO 100  //constante do arranjo
#define false 1
#define true 0

struct TNodo 
{
    int info;
    int prox;
};

TNodo ar[QTNO];

int le,pl;

void Criar_Les(int prim,int ult); //função criar uma lista vazia


int Alocar_Les();  //função p/ alocar uma posição livre no arranjo.
                   // Ela sempre retorna o indice da primeira posição livre ou nulo caso não haja espaço disponível


void Liberar_Les(int k); //função p/ liberar uma posição no arranjo
                                                                                         

void Criar_Les(int prim,int ult) //função criar uma lista vazia
{
     int ind;
     le=nulo;
     pl=prim;
     
     for(ind=prim;ult-1;ind++)
     {//encadeamento dos nodos da lista de posições
       ar[ind].prox=ind+1;
     }
     ar[ult].prox=nulo;
     
}


int Alocar_Les()
{
    int aux;
    aux=pl;
    if (aux!=nulo)
    {
        pl=ar[aux].prox;
    }
    return aux;
}




void Liberar_Les(int k)
{
     int aux;
     ar[k].prox=pl;
     pl=k;
 }


int inserirNI_LES(int Pinfo) 
{
    int nn;
    int res;
    res=1;
    nn = Alocar_Les();
       if (nn==nulo)
       printf("não há espaço disponivel");
    else 
    {
         res=0;
         ar[nn].prox= le;
         ar[nn].info=Pinfo;
         le=nn;
    }
    return res;
}
    
int inserirNF_LES(int Pinfo) 
{
    int nn,un;
    int res;
    res=1;
    nn = Alocar_Les();
       if (nn==nulo)
       printf("não há espaço disponivel");
    else 
    {
         res=0;
         ar[nn].info= Pinfo;
         un=le;
         if (le != nulo) 
         {
                while(ar[un].prox != nulo) 
                {
                un=ar[un].prox;
                }
             ar[nn].prox=ar[un].prox;
             ar[un].prox= nn;
         }
         else 
         {
              ar[nn].prox= le;
              le=nn;
         }
    }
    return res;
}

int inserirNE_LES(int k, int Pinfo) 
{
    int nn,na,aux;
    int res;
    res=1;
    if (k<1) 
    {
       printf("posiçao invalida!");
       system("pause");
    }
    else 
    {
         aux=1;
         while((ar[na].prox!= nulo) && (aux < k-1) ) 
         {
                na = ar[na].prox;
                aux= aux+1;
         }
    }
    if ((k==1) | (aux==k-1)) 
    {
               nn = Alocar_Les();
               if (nn==nulo) 
               {
                  printf("Não há espaço disponivel");
                  return res;
                  system("pause");
               }
               ar[nn].info=Pinfo;
               ar[nn].prox=nulo;
               if(k==1) 
               {
                        ar[nn].prox=le;
                        le=nn;
                        res=0;
               }
               else 
               {
                    ar[nn].prox= ar[na].prox;
                    ar[na].prox= nn;
                    res=0;
               }
     }
     return res;
}
               


int main(int argc, char *argv[])
{
    int i,prim,ult,k,;
    i=nulo;
    if (i==nulo)
    {
       printf("Valor nulo\n");         
    }
    else
    {
        Criar_Les(prim,ult);
        Alocar_Les();
        Liberar_Les(k);
        //inserirNI_LES(Pinfo);
    }
    system ("pause");
    return 0;
}

Até que comecei.. no sei se to indo no caminho certo... mas a dúvida maior é de como vou definir o tamanho das listas dentro dentro de um mesmo arranjo....

estou indo no caminho certo????

OBRIGADA!!!

[p4t0X]

Boa tarde,

Não entendi direito, o que seria um arranjo para você?!

Na minha opinião, a alocação de memória deve ser feita dinamicamente, e não estaticamente como é o atual!

[]'s

Diego

[Eliza21]

Segundo o professor... o arranjo seria:

Por exemplo: Um vetor de 100 posições... onde nele seriam alocadas varias listas encadeadas(de tamanho definido pelo usuário)...

entendeu?

Desde já agradeço sua atenção...

[p4t0X]

Intendi!

Pelo jeito o professor ainda não ensinou alocação dinâmica né?

To indo pra facul, a noite eu edito o post aqui!