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

 

 


Tema destacado: Introducción a la Factorización De Semiprimos (RSA)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Lista enlazada simples
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Lista enlazada simples  (Leído 1,456 veces)
angie07

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Lista enlazada simples
« en: 12 Noviembre 2016, 16:54 pm »

Buenos días
Necesito generar listas enlazada de números aleatorios enteros y ordenarlos por el método de ordenamiento burbuja

Este es el codigo que estoy manejando pero no se como hacer la parte del ordenamiento con las listas y la parte aleatoria

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. typedef struct _nodo{
  6.    int numero;
  7.    struct _nodo *siguiente;
  8. }_Nodo;
  9.  
  10. typedef _Nodo * _pNodo;
  11.  
  12. _pNodo CrearLista(int numero)
  13. {
  14.    _pNodo Lista;
  15.  
  16.    Lista = (_pNodo)malloc(sizeof(_Nodo));
  17.    Lista->numero = numero;
  18.    Lista->siguiente = NULL;
  19.  
  20.    return Lista;
  21. }
  22.  
  23. _pNodo InsertarElementoAlFinal(int numero, _pNodo ListaInicial)
  24. {
  25.    _pNodo NuevoNodo;
  26.    _pNodo Auxiliar = ListaInicial;
  27.    NuevoNodo = malloc(sizeof(_Nodo));
  28.  
  29.    NuevoNodo->numero = numero;
  30.    NuevoNodo->siguiente = NULL;
  31.  
  32.    if(ListaInicial->siguiente == NULL)
  33.    {
  34.        ListaInicial->siguiente = NuevoNodo;
  35.    }
  36.    else
  37.    {
  38.        while(Auxiliar->siguiente != NULL)
  39.        {
  40.            Auxiliar = Auxiliar->siguiente;
  41.        }
  42.        Auxiliar->siguiente = NuevoNodo;
  43.    }
  44.    return NuevoNodo; ///RETORNAMOS DIRECCIÓN DEL ELEMENTO INSERTADO
  45. }
  46.  
  47. _pNodo InsertarElementoAlInicio(int numero, _pNodo ListaInicial)
  48. {
  49.    _pNodo NuevoNodo;
  50.    NuevoNodo = malloc(sizeof(_Nodo));
  51.    NuevoNodo->numero = numero;
  52.    NuevoNodo->siguiente = ListaInicial;
  53.  
  54.    return NuevoNodo; ///RETORNAMOS NUEVA LISTA INICIAL
  55. }
  56.  
  57. _pNodo InsertarElementoPosterior(int numero, _pNodo ElementoAnterior)
  58. {
  59.    _pNodo NuevoNodo;
  60.    NuevoNodo = malloc(sizeof(_Nodo));
  61.  
  62.    NuevoNodo->numero = numero;
  63.    NuevoNodo->siguiente = ElementoAnterior->siguiente;
  64.  
  65.    ElementoAnterior->siguiente = NuevoNodo;
  66.  
  67.    return NuevoNodo; ///RETORNAMOS DIRECCIÓN DEL ELEMENTO INSERTADO
  68. }
  69.  
  70. _pNodo EliminarPrimerElemento(_pNodo Lista)
  71. {
  72.    _pNodo Auxiliar;
  73.    Auxiliar = Lista;
  74.  
  75.    if(Auxiliar->siguiente == NULL)
  76.    {
  77.        return Lista; ///SI NO HAY ELEMENTOS DEJAMOS TODO IGUAL
  78.    }
  79.    Lista = Auxiliar->siguiente;
  80.    free(Auxiliar);
  81.  
  82.    return Lista; ///RETORNAMOS LA NUEVA BASE DE LA LISTA
  83. }
  84.  
  85. ///ELIMINAMOS ELEMENTO POR SU DIRECCIÓN
  86. int EliminarElemento(_pNodo Elemento, _pNodo Lista)
  87. {
  88.    _pNodo Auxiliar;
  89.    Auxiliar = Lista;
  90.    while(Auxiliar != NULL)
  91.    {
  92.        if(Auxiliar->siguiente == Elemento)
  93.        {
  94.            break;
  95.        }
  96.        Auxiliar = Auxiliar->siguiente;
  97.    }
  98.    if(Auxiliar == NULL)
  99.    {
  100.        return 0;
  101.    }
  102.    else
  103.    {
  104.        if(Elemento->siguiente == NULL)
  105.        {
  106.            Auxiliar->siguiente = NULL;
  107.        }
  108.        else
  109.        {
  110.            Auxiliar->siguiente = Elemento->siguiente;
  111.        }
  112.        free(Elemento);
  113.        return 1;
  114.    }
  115. }
  116.  
  117. ///BUSQUEDA DE ELEMENTOS
  118. _pNodo BuscarElemento(int numero, _pNodo Lista)
  119. {
  120.    _pNodo Auxiliar;
  121.  
  122.    Auxiliar = Lista;
  123.    while(Auxiliar != NULL)
  124.    {
  125.        if(Auxiliar->numero == numero)
  126.        {
  127.            break;
  128.        }
  129.        Auxiliar = Auxiliar->siguiente;
  130.    }
  131.    return Auxiliar; ///RETORNAMOS DIRECCIÓN DEL ELEMENTO ENCONTRADO
  132. }
  133.  
  134. void OrdenarLista()
  135. {
  136.    _Nodo *p=NULL;
  137.    _Nodo *t=NULL;
  138.    int temp, i, j;
  139.  
  140.    for(i=0;i<15; i++)
  141.    {
  142.        for(j=0;j<15;j++)
  143.        {
  144.            if(numero[j]>numero[j+1])
  145.            {
  146.                temp = numero[j];
  147.                numero[j] = numero[j+1];
  148.                numero[j+1] = temp;
  149.        }
  150.    }
  151. }
  152.  
  153. ///ASCENDENTE
  154. for(i=0; i<15; i++)
  155. {
  156.    printf("%d ",numero[i]);
  157. }
  158. }
  159.  
  160. int main(){
  161.  
  162.    CrearLista();
  163.  
  164.    int num,i;
  165.  
  166.    srand(time(NULL));
  167.  
  168.    for(i=1; i<=15; i=i+1)
  169.    {
  170.        num = 1+ rand()%51;
  171.        printf("\tELEMENTOS: %d")
  172.    }
  173.  
  174.    return 0;
  175. }
  176.  
Espero me puedan ayuda, gracias.


Mod: Los códigos deben ir en etiquetas GeSHi


« Última modificación: 12 Noviembre 2016, 16:58 pm por engel lex » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Problema con lista enlazada
Programación C/C++
Lain0x 2 3,393 Último mensaje 8 Julio 2011, 13:20 pm
por Valkyr
Ayuda con lista enlazada
Java
netca 2 3,145 Último mensaje 20 Abril 2012, 16:11 pm
por adwind
Ayuda Lista Enlazada
Programación C/C++
robluis 5 5,392 Último mensaje 9 Mayo 2012, 03:49 am
por botella
lista enlazada ayudita
Programación C/C++
bash 3 1,783 Último mensaje 6 Marzo 2015, 08:12 am
por eferion
lista doblemente enlazada
Programación C/C++
d91 1 1,905 Último mensaje 19 Octubre 2015, 04:06 am
por d91
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines