elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  ayuda estar bien realizado este taller de listas, pilas y colas. denle una vista
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: ayuda estar bien realizado este taller de listas, pilas y colas. denle una vista  (Leído 937 veces)
creiko

Desconectado Desconectado

Mensajes: 44


Ver Perfil
ayuda estar bien realizado este taller de listas, pilas y colas. denle una vista
« en: 4 Diciembre 2016, 22:21 »

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
  1.  
  2. #include <stdio.h>
  3. #include <iostream>
  4. #include <stdlib.h>
  5. #define localizar (struct nodo*) malloc(sizeof(struct nodo));
  6. #define memoria_doble (struct list_doble*) malloc(sizeof(struct list_doble));
  7. using namespace std;
  8.  
  9. struct nodo
  10. {
  11.  int inf;
  12.  struct nodo *sig;
  13. };
  14. struct list_doble
  15. {
  16.  nodo *list;
  17.  struct list_doble *enlace;
  18. };
  19. nodo *lista1 = NULL, *lista2 = NULL;
  20. int n_nodos(nodo *);
  21. //void crear_lista(nodo **);
  22. bool crear_nodo();
  23. nodo *concatenar_lista();
  24. void llenar_listas();
  25. void mostrar_lista(nodo*);
  26. nodo *hacer_nodo();
  27. void lista_rota(nodo *, nodo*);
  28. nodo *buscar_nodo(int);
  29. void retirar_nodo(nodo *);
  30. nodo *liberar_nodos(nodo **);
  31. void invertir_lista(nodo **);
  32. list_doble *doble_puntero(nodo *);
  33. int main()
  34. {
  35.  int opc,num_nodo=0,i=1;
  36.  nodo *ele;
  37.  list_doble *prueba=NULL;
  38.  char enter;
  39.  do
  40.  {
  41.    cout<<"\nMENU LISTAS\n\n"
  42.        <<"1)\n"
  43.        <<"2)Numero de nodos de la lista.\n"
  44.        <<"3)Concatenar listas.\n"
  45.        <<"4)Informacion mayor y menor a un nodo de la lista.\n"
  46.        <<"5)Sacar un nodo de la lista.\n"
  47.        <<"6)Liberar todos los nodos de la lista.\n"
  48.        <<"7)Invertir la lista(en un recorrido).\n"
  49.        <<"8)Nodos pares he impares de la lista.\n"
  50.        <<"9)Llenar lista.\n"
  51.        <<"10)Mostrar lista.\n"
  52.        <<"11)Salir\n"
  53.        <<"opcion: ";
  54.        cin>>opc;
  55.        if(opc != 11)
  56.        {
  57.          system("clear"); //system("cls") para windows
  58.        }
  59.    switch(opc)
  60.    {
  61.      case 1:break;
  62.  
  63.      case 2: cout<<"\nEl numero de nodos de la lista es: "<<n_nodos(lista1)<<endl;
  64.              break;
  65.  
  66.      case 3: llenar_listas();
  67.              break;
  68.      case 4: mostrar_lista(lista1);
  69.              cout<<"\nIngresa el numero de un nodo a buscar: ";
  70.              cin>>num_nodo;
  71.              ele = buscar_nodo(num_nodo);
  72.              if(ele != NULL)
  73.              {
  74.                cout<<"Lista dividida";
  75.                lista_rota(lista1,ele);
  76.              }else
  77.              {
  78.                cout<<"\nNodo no encontrado."<<endl;
  79.              }
  80.              ele=NULL;
  81.              break;
  82.      case 5: cout<<"Lista de datos: \n";
  83.              mostrar_lista(lista1);
  84.              cout<<"Nodo a retirar: ";
  85.              cin>>num_nodo;
  86.              ele = buscar_nodo(num_nodo);
  87.              if(ele != NULL)
  88.              {
  89.                retirar_nodo(ele);
  90.                cout<<"\nNodo retirado correctamente\n";
  91.  
  92.              }else
  93.              {
  94.                cout<<"\nNodo no encontrado."<<endl;
  95.              }
  96.              ele=NULL;
  97.              break;
  98.      case 6: ele = liberar_nodos(&lista1);
  99.              if(ele == NULL)
  100.              {
  101.                cout<<"\nMemoria liberada.\n";
  102.              }else
  103.              {
  104.                cout<<"\nFallo al liberar memoria\n";
  105.              }
  106.              ele = NULL;
  107.              break;
  108.      case 7: cout<<"\nDatos de lista: \n";
  109.              mostrar_lista(lista1);
  110.              invertir_lista(&lista1);
  111.              cout<<"\nLista invertida: \n";
  112.              mostrar_lista(lista1);
  113.              break;
  114.      case 8: cout<<"\nDatos de lista: \n";
  115.              mostrar_lista(lista1);
  116.              prueba = doble_puntero(lista1);
  117.              while(prueba != NULL)
  118.              {
  119.                if(i % 2 == 1)cout<<"\nDatos pares\n";
  120.                else cout<<"\nDatos impares\n";
  121.                invertir_lista(&prueba->list);
  122.                mostrar_lista(prueba->list);
  123.                prueba = prueba->enlace;
  124.                i++;
  125.              }
  126.                break;
  127.      case 9: lista1 = hacer_nodo();
  128.              break;
  129.      case 10:  mostrar_lista(lista1);
  130.                break;
  131.      case 11:  cout<<"\nGracias por usar saliendo...............\n";
  132.                break;
  133.      default: cout<<"La opcion no esta en el rango."<<endl;
  134.    }
  135.  
  136.  }while(opc != 11);
  137. /*
  138.  
  139.  
  140.  
  141.   8.
  142.  
  143.   lista1 = hacer_nodo();
  144.   mostrar_lista(lista1);
  145.   prueba = doble_puntero(lista1);
  146.   cout<<"\n\n";
  147.   while(prueba != NULL)
  148.   {
  149.     invertir_lista(&prueba->list);
  150.     mostrar_lista(prueba->list);
  151.     prueba = prueba->enlace;
  152.     cout<<"\n";
  153.   }
  154.   */
  155.  
  156.  printf("\n");
  157.  return 0;
  158. }
  159. list_doble *doble_puntero(nodo *lista)
  160. {
  161.  
  162.  nodo *list_impares=NULL,*impAux=NULL, *list_pares=NULL,*parAux=NULL;
  163.  list_doble *list_new=NULL, *aux_new=NULL;
  164.  int i = 1,t=2;
  165.  
  166.  while(lista != NULL)
  167.  {
  168.  
  169.    if(i % 2 == 0)
  170.    {
  171.      parAux = localizar;
  172.      parAux->inf = lista->inf;
  173.      parAux->sig = list_pares;
  174.      list_pares = parAux;
  175.    }else
  176.    {
  177.      impAux = localizar;
  178.      impAux->inf = lista->inf;
  179.      impAux->sig = list_impares;
  180.      list_impares = impAux;
  181.    }
  182.    lista = lista->sig;
  183.    i++;
  184.  
  185.  }
  186.  
  187.  for(int i = 1; i <= t; i++)
  188.  {
  189.  
  190.    aux_new = memoria_doble;
  191.    if(i % 2 == 0)aux_new->list = list_pares;
  192.    else aux_new->list = list_impares;
  193.    aux_new->enlace = list_new;
  194.    list_new = aux_new;
  195.  }
  196.  
  197.  return list_new;
  198. }
  199.  
  200.  
  201. void invertir_lista(nodo **ini)
  202. {
  203.  nodo *sig=NULL,
  204.       *aux2=NULL,
  205.       *aux=NULL;
  206.        aux2=*ini;
  207.  
  208.  do{
  209.    sig = aux2->sig;
  210.  
  211.    aux2->sig = aux;
  212.    aux = aux2;
  213.  
  214.    if(sig != NULL)
  215.    {
  216.      aux2 = sig;
  217.    }else
  218.    {
  219.      *ini = aux2;
  220.    }
  221.  
  222.  }while(*ini != aux2);
  223. }
  224.  
  225. nodo *liberar_nodos(nodo **ini)
  226. {
  227.  
  228.  while(*ini != NULL)
  229.  {
  230.    free(*ini);
  231.    *ini = (*ini)->sig;
  232.  }
  233.  *ini = NULL;
  234.  return *ini;
  235. }
  236. void retirar_nodo(nodo *d_nod)
  237. {
  238.  nodo *aux = NULL, *q = NULL, *r = NULL,*n_despa=NULL;
  239.  bool retirado = false;
  240.  aux = lista1;
  241.  int cont = 1;
  242.  
  243.  while(aux != NULL && retirado == false)
  244.  {
  245.    if(cont == 1 && aux == d_nod)
  246.    {
  247.      r = lista1;
  248.      n_despa = r;
  249.      lista1 = lista1->sig;
  250.      retirado = true;
  251.    }else
  252.    {
  253.        cont = 2;
  254.        q = aux->sig;
  255.        if(q == d_nod)
  256.        {
  257.          aux->sig = q->sig;
  258.          n_despa = q;
  259.          retirado = true;
  260.        }
  261.      }
  262.    aux = aux->sig;
  263.  }
  264. }
  265.  
  266. nodo *buscar_nodo(int x)
  267. {
  268.  nodo *aux = NULL,*EleBus=NULL;
  269.  bool encontrado = false;
  270.  aux = lista1;
  271.  int i = 1;
  272.  while(aux != NULL && encontrado == false)
  273.  {
  274.    if(x == i)
  275.    {
  276.      EleBus = aux;
  277.      encontrado = true;
  278.    }
  279.    aux = aux->sig;
  280.    i = i + 1;
  281.  }
  282. //  if(encontrado) return EleBus;
  283. //  else return EleBus = NULL;
  284.  return EleBus;
  285. }
  286.  
  287. void lista_rota(nodo *cad, nodo *q)
  288. {
  289.  nodo *listaA=NULL,*a=NULL, *listaB=NULL,*b=NULL;
  290.  while(cad != NULL)
  291.  {
  292.    if(cad->inf < q->inf)
  293.    {
  294.      a = localizar;
  295.      a->inf = cad->inf;
  296.      a->sig = listaA;
  297.      listaA = a;
  298.    }
  299.    if(cad->inf >= q->inf && &cad->inf != &q->inf)
  300.    {
  301.      b = localizar;
  302.      b->inf = cad->inf;
  303.      b->sig = listaB;
  304.      listaB = b;
  305.    }
  306.    cad = cad->sig;
  307.  }
  308.  printf("\nLista con los elementos menores a %d \n",q->inf);
  309.  mostrar_lista(listaA);
  310.  printf("\nLista con los elementos mayores o iguales a %d \n",q->inf);
  311.  mostrar_lista(listaB);
  312. }
  313.  
  314. nodo *hacer_nodo()
  315. {
  316.  nodo *p=NULL, *q=NULL;
  317.  //char cr[2];
  318.  
  319.  while(crear_nodo())
  320.  {
  321.    q = (struct nodo*) malloc(sizeof(struct nodo));
  322.    cout<<"valor para el nodo: ";
  323.    cin>>q->inf;
  324.    cin.ignore(256,'\n');
  325.    q->sig = p;
  326.    p = q;
  327.  }
  328.  return p;
  329. }
  330.  
  331. void mostrar_lista(nodo *list)
  332. {
  333.  int i = 1;
  334.  while(list != NULL)
  335.  {
  336.    printf("%d) %d\n",i,list->inf);
  337.    list = list->sig;
  338.    i = i + 1;
  339.  }
  340. }
  341.  
  342.  
  343. void llenar_listas()
  344. {
  345.  nodo *list=NULL;
  346.  printf("\nLista A: \n");
  347.  lista1 = hacer_nodo();
  348.  printf("\nLista B: \n");
  349.  lista2 = hacer_nodo();
  350.  
  351.  printf("Lista A\n");
  352.  mostrar_lista(lista1);
  353.  
  354.  printf("Lista B\n");
  355.  mostrar_lista(lista2);
  356.  
  357.  printf("Lista concatenada: \n");
  358.  list = concatenar_lista();
  359.  
  360.  mostrar_lista(list);
  361. }
  362.  
  363. nodo *concatenar_lista()
  364. {
  365.  
  366.  nodo *eleFin = NULL;
  367.  bool agregado = false;
  368.  nodo *aux = NULL;
  369.  aux = lista1;
  370.  
  371.  if(aux == NULL)
  372.  {
  373.    lista1 = lista2;
  374.  }else
  375.  {
  376.    while(aux != NULL && agregado == false)
  377.    {
  378.        if(aux->sig == NULL)
  379.        {
  380.          aux->sig = lista2;
  381.          agregado = true;
  382.        }
  383.        aux = aux->sig;
  384.    }
  385.  }
  386.  eleFin = lista1;
  387.  return eleFin;
  388. }
  389.  
  390. int n_nodos(nodo *ini)
  391. {
  392.  
  393.  int c_nodos = 0;
  394.  while(ini != NULL)
  395.  {
  396.    c_nodos++;
  397.    ini = ini->sig;
  398.  }
  399.  return c_nodos;
  400. }
  401.  
  402. bool crear_nodo()
  403. {
  404.  char resp;
  405.  cout << "\nDesear crear un nodo? s/n: ";
  406.  cin>>resp;
  407.  if(resp == 's' || resp == 'S')return true;
  408.  else return false;
  409. //  return (resp == 's' || resp == 'S');
  410. }
  411.  
  412.  


MOD: Imagenes adaptadas a lo permitido.


« Última modificación: 5 Diciembre 2016, 13:16 por MCKSys Argentina » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda con Pilas y Colas
Programación Visual Basic
[Decoded] 5 6,755 Último mensaje 30 Agosto 2010, 15:06
por goldarg
Ayuda con Pilas y Colas
Programación C/C++
HeavyPsychedelic 1 2,034 Último mensaje 26 Octubre 2010, 18:57
por Littlehorse
ayuda con codigo de c++ programa para hacer sorteo usando listas y colas
Programación C/C++
carles24 3 5,630 Último mensaje 5 Noviembre 2011, 19:10
por carles24
Ayuda con listas, pilas y colas
Programación C/C++
VintageChanel 1 963 Último mensaje 28 Enero 2015, 08:43
por Orubatosu
Pilas y colas
Programación C/C++
DEaniz 7 1,346 Último mensaje 19 Junio 2015, 13:16
por ivancea96
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines