ayuda estar bien realizado este taller de listas, pilas y colas. denle una vista

[creiko]

Hola buenas me dejaron este trabajo en la universidad, alguien que sepa del tema me diga si esta bien hecho y si hay lago que mejorar me dice como gracias
adjunto lo que hice y el taller

1.   Elaborar una función que reciba el apuntador al primer nodo de la lista y devuelva el numero e nodos que lo componen

2.   Elaborar una función que reciba un apuntador P que apunta al primer nodo De una lista y un apuntador Q que apunta al primer nodo de una segunda lista. La función debe concatenar las dos listas así: el final de la primera lista debe encadenarse con el comienzo de la segunda lista. Cualquiera de las listas, o las dos, pueden estar vacías.


3.   Elaborar una función que reciba dos apuntadores, el apuntador CAB que apunta al primer nodo de la lista y un apuntador Q que apunta a cualquier nodo de la lista. La lista no se encuentra clasificada ascendente. La función debe romper la lista en dos. La primera lista debe incluir todos los nodos cuya información sea menor a Q -> INFO y la segunda todos los nodos cuya información sea mayor o igual a Q -> INFO

4.   elaborar una función que reciba la dirección de cualquier nodo en una lista. la función debe retirar ese nodo de la lista. ¿cuál no es imposible retirar de la lista?
NOTA:  la función solamente recibe un apuntador.


5.   Elaborar una función que reciba el apuntador al primer nodo de la lista y libere todos los nodos de la lista utilizando para cada uno la instrucción FREE (). Se debe devolver el apuntador recibido con el valor NULL.

6.   elaborar una función que reciba un apuntador al primer nodo de una lista. la función debe invertir la lista. la lista debe ser invertida recorriéndola solamente una vez. al final cada nodo debe apuntar al nodo que antes era su predecesor. la cabeza de la lista debe ser el nodo que al comienzo estaba al final y el nodo que antes era el primero, debe tener el valor NULL. gráficamente seria




7.elaborar una función que reciba un apuntador al primer nodo de una lista y devuelva dos apuntadores. el primer debe apuntar a una lista conformada por los nodos impares e la lista inicial y el segundo debe apuntar a una lista conformada por los dos nodos pares de la lista inicial. al final de la lista inicial debe liberarse de la memoria. por ejemplo, si la lista era:

Código (cpp) [Seleccionar] Expandir



#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#define localizar (struct nodo*) malloc(sizeof(struct nodo));
#define memoria_doble (struct list_doble*) malloc(sizeof(struct list_doble));
using namespace std;

struct nodo
{
  int inf;
  struct nodo *sig;
};
struct list_doble
{
  nodo *list;
  struct list_doble *enlace;
};
nodo *lista1 = NULL, *lista2 = NULL;
int n_nodos(nodo *);
//void crear_lista(nodo **);
bool crear_nodo();
nodo *concatenar_lista();
void llenar_listas();
void mostrar_lista(nodo*);
nodo *hacer_nodo();
void lista_rota(nodo *, nodo*);
nodo *buscar_nodo(int);
void retirar_nodo(nodo *);
nodo *liberar_nodos(nodo **);
void invertir_lista(nodo **);
list_doble *doble_puntero(nodo *);
int main()
{
  int opc,num_nodo=0,i=1;
  nodo *ele;
  list_doble *prueba=NULL;
  char enter;
  do
  {
    cout<<"\nMENU LISTAS\n\n"
        <<"1)\n"
        <<"2)Numero de nodos de la lista.\n"
        <<"3)Concatenar listas.\n"
        <<"4)Informacion mayor y menor a un nodo de la lista.\n"
        <<"5)Sacar un nodo de la lista.\n"
        <<"6)Liberar todos los nodos de la lista.\n"
        <<"7)Invertir la lista(en un recorrido).\n"
        <<"8)Nodos pares he impares de la lista.\n"
        <<"9)Llenar lista.\n"
        <<"10)Mostrar lista.\n"
        <<"11)Salir\n"
        <<"opcion: ";
        cin>>opc;
        if(opc != 11)
        {
          system("clear"); //system("cls") para windows
        }
    switch(opc)
    {
      case 1:break;

      case 2: cout<<"\nEl numero de nodos de la lista es: "<<n_nodos(lista1)<<endl;
              break;

      case 3: llenar_listas();
              break;
      case 4: mostrar_lista(lista1);
              cout<<"\nIngresa el numero de un nodo a buscar: ";
              cin>>num_nodo;
              ele = buscar_nodo(num_nodo);
              if(ele != NULL)
              {
                cout<<"Lista dividida";
                lista_rota(lista1,ele);
              }else
              {
                cout<<"\nNodo no encontrado."<<endl;
              }
              ele=NULL;
              break;
      case 5: cout<<"Lista de datos: \n";
              mostrar_lista(lista1);
              cout<<"Nodo a retirar: ";
              cin>>num_nodo;
              ele = buscar_nodo(num_nodo);
              if(ele != NULL)
              {
                retirar_nodo(ele);
                cout<<"\nNodo retirado correctamente\n";

              }else
              {
                cout<<"\nNodo no encontrado."<<endl;
              }
              ele=NULL;
              break;
      case 6: ele = liberar_nodos(&lista1);
              if(ele == NULL)
              {
                cout<<"\nMemoria liberada.\n";
              }else
              {
                cout<<"\nFallo al liberar memoria\n";
              }
              ele = NULL;
              break;
      case 7: cout<<"\nDatos de lista: \n";
              mostrar_lista(lista1);
              invertir_lista(&lista1);
              cout<<"\nLista invertida: \n";
              mostrar_lista(lista1);
              break;
      case 8: cout<<"\nDatos de lista: \n";
              mostrar_lista(lista1);
              prueba = doble_puntero(lista1);
              while(prueba != NULL)
              {
                if(i % 2 == 1)cout<<"\nDatos pares\n";
                else cout<<"\nDatos impares\n";
                invertir_lista(&prueba->list);
                mostrar_lista(prueba->list);
                prueba = prueba->enlace;
                i++;
              }
                break;
      case 9: lista1 = hacer_nodo();
              break;
      case 10:  mostrar_lista(lista1);
                break;
      case 11:  cout<<"\nGracias por usar saliendo...............\n";
                break;
      default: cout<<"La opcion no esta en el rango."<<endl;
    }

  }while(opc != 11);
/*



  8.

  lista1 = hacer_nodo();
  mostrar_lista(lista1);
  prueba = doble_puntero(lista1);
  cout<<"\n\n";
  while(prueba != NULL)
  {
    invertir_lista(&prueba->list);
    mostrar_lista(prueba->list);
    prueba = prueba->enlace;
    cout<<"\n";
  }
  */

  printf("\n");
  return 0;
}
list_doble *doble_puntero(nodo *lista)
{

  nodo *list_impares=NULL,*impAux=NULL, *list_pares=NULL,*parAux=NULL;
  list_doble *list_new=NULL, *aux_new=NULL;
  int i = 1,t=2;

  while(lista != NULL)
  {

    if(i % 2 == 0)
    {
      parAux = localizar;
      parAux->inf = lista->inf;
      parAux->sig = list_pares;
      list_pares = parAux;
    }else
    {
      impAux = localizar;
      impAux->inf = lista->inf;
      impAux->sig = list_impares;
      list_impares = impAux;
    }
    lista = lista->sig;
    i++;

  }

  for(int i = 1; i <= t; i++)
  {

    aux_new = memoria_doble;
    if(i % 2 == 0)aux_new->list = list_pares;
    else aux_new->list = list_impares;
    aux_new->enlace = list_new;
    list_new = aux_new;
  }

  return list_new;
}


void invertir_lista(nodo **ini)
{
  nodo *sig=NULL,
       *aux2=NULL,
       *aux=NULL;
        aux2=*ini;

  do{
    sig = aux2->sig;

    aux2->sig = aux;
    aux = aux2;

    if(sig != NULL)
    {
      aux2 = sig;
    }else
    {
      *ini = aux2;
    }

  }while(*ini != aux2);
}

nodo *liberar_nodos(nodo **ini)
{

  while(*ini != NULL)
  {
    free(*ini);
    *ini = (*ini)->sig;
  }
  *ini = NULL;
  return *ini;
}
void retirar_nodo(nodo *d_nod)
{
  nodo *aux = NULL, *q = NULL, *r = NULL,*n_despa=NULL;
  bool retirado = false;
  aux = lista1;
  int cont = 1;

  while(aux != NULL && retirado == false)
  {
    if(cont == 1 && aux == d_nod)
    {
      r = lista1;
      n_despa = r;
      lista1 = lista1->sig;
      retirado = true;
    }else
    {
        cont = 2;
        q = aux->sig;
        if(q == d_nod)
        {
          aux->sig = q->sig;
          n_despa = q;
          retirado = true;
        }
      }
    aux = aux->sig;
  }
}

nodo *buscar_nodo(int x)
{
  nodo *aux = NULL,*EleBus=NULL;
  bool encontrado = false;
  aux = lista1;
  int i = 1;
  while(aux != NULL && encontrado == false)
  {
    if(x == i)
    {
      EleBus = aux;
      encontrado = true;
    }
    aux = aux->sig;
    i = i + 1;
  }
//  if(encontrado) return EleBus;
//  else return EleBus = NULL;
  return EleBus;
}

void lista_rota(nodo *cad, nodo *q)
{
  nodo *listaA=NULL,*a=NULL, *listaB=NULL,*b=NULL;
  while(cad != NULL)
  {
    if(cad->inf < q->inf)
    {
      a = localizar;
      a->inf = cad->inf;
      a->sig = listaA;
      listaA = a;
    }
    if(cad->inf >= q->inf && &cad->inf != &q->inf)
    {
      b = localizar;
      b->inf = cad->inf;
      b->sig = listaB;
      listaB = b;
    }
    cad = cad->sig;
  }
  printf("\nLista con los elementos menores a %d \n",q->inf);
  mostrar_lista(listaA);
  printf("\nLista con los elementos mayores o iguales a %d \n",q->inf);
  mostrar_lista(listaB);
}

nodo *hacer_nodo()
{
  nodo *p=NULL, *q=NULL;
  //char cr[2];

  while(crear_nodo())
  {
    q = (struct nodo*) malloc(sizeof(struct nodo));
    cout<<"valor para el nodo: ";
    cin>>q->inf;
    cin.ignore(256,'\n');
    q->sig = p;
    p = q;
  }
  return p;
}

void mostrar_lista(nodo *list)
{
  int i = 1;
  while(list != NULL)
  {
    printf("%d) %d\n",i,list->inf);
    list = list->sig;
    i = i + 1;
  }
}


void llenar_listas()
{
  nodo *list=NULL;
  printf("\nLista A: \n");
  lista1 = hacer_nodo();
  printf("\nLista B: \n");
  lista2 = hacer_nodo();

  printf("Lista A\n");
  mostrar_lista(lista1);

  printf("Lista B\n");
  mostrar_lista(lista2);

  printf("Lista concatenada: \n");
  list = concatenar_lista();

  mostrar_lista(list);
}

nodo *concatenar_lista()
{

  nodo *eleFin = NULL;
  bool agregado = false;
  nodo *aux = NULL;
  aux = lista1;

  if(aux == NULL)
  {
    lista1 = lista2;
  }else
  {
    while(aux != NULL && agregado == false)
    {
        if(aux->sig == NULL)
        {
          aux->sig = lista2;
          agregado = true;
        }
        aux = aux->sig;
    }
  }
  eleFin = lista1;
  return eleFin;
}

int n_nodos(nodo *ini)
{

  int c_nodos = 0;
  while(ini != NULL)
  {
    c_nodos++;
    ini = ini->sig;
  }
  return c_nodos;
}

bool crear_nodo()
{
  char resp;
  cout << "\nDesear crear un nodo? s/n: ";
  cin>>resp;
  if(resp == 's' || resp == 'S')return true;
  else return false;
//  return (resp == 's' || resp == 'S');
}




MOD: Imagenes adaptadas a lo permitido.