Foro de elhacker.net

#include <iostream>
#include <stdlib.h>
 
using namespace std;
 
typedef struct tnodo *pnodo;
typedef struct tnodo{
	int dato;
	pnodo sig;
	};
 
void inicia(pnodo &lista);
void crear(pnodo &nuevo);
void agregar_final(pnodo &lista, pnodo nuevo);
void ordenar_lista(pnodo &lista);
void mostrar(pnodo lista);
 
int main()
{
	pnodo milista, nuevo;
	int opcion;
	inicia(milista);
	do{
		system("cls");
		cout << "1. Iniciar lista" << endl;
		cout << "2. Agregar elemento" << endl;
		cout << "3. Ordenar lista" << endl;
		cout << "4. Mostrar lista" << endl;
		cout << "5. Salir" << endl;
		cin >> opcion;
		switch(opcion){
			case 1: inicia(milista); break;
			case 2: crear(nuevo); if(nuevo!=NULL){agregar_final(milista,nuevo);}; break;
			case 3: ordenar_lista(milista); break;
			case 4:	cout << "*** LISTA ***" << endl; mostrar(milista); break;
			case 5: cout << "FIN DEL  PROGRAMA" << endl; break;
			default: cout << "Opcion incorrecta" << endl;
		}
	system("pause");
	}while(opcion!=5);
}
 
void inicia(pnodo &lista)
{
	lista=NULL;
}
 
void crear(pnodo &nuevo)
{
	nuevo=new tnodo;
	if(nuevo!=NULL){
		cout << "Ingrese valor: "; cin >> nuevo->dato;
		nuevo->sig=NULL;
	}
	else{
		cout << "MEMORIA INSUFICIENTE" << endl;
	}
}
 
void agregar_final(pnodo &lista, pnodo nuevo)
{
	pnodo i;
	if(lista==NULL){
		lista=nuevo;
	}
	else{
		for(i=lista;i->sig!=NULL;i=i->sig);
		i->sig=nuevo;
	}
}
 
void ordenar_lista(pnodo &lista)
{
	pnodo i, j, min;
	int aux;
	for(i=lista;i->sig!=NULL;i=i->sig){
		min=i;
		for(j=lista;j->sig!=NULL;j=j->sig){
			j=i->sig;
			if(j->dato<i->dato){
				min->dato=j->dato;
				min->sig=j->sig;
			}
		}
		aux=i->dato;
		i->dato=min->dato;
		min->dato=aux;
	}
}
 
void mostrar(pnodo lista)
{
	pnodo i;
	if(lista!=NULL){
		for(i=lista;i!=NULL;i=i->sig){
			cout << "Nodo: " << i->dato << endl;
		}
		cout << endl;
	}
	else{
		cout << "LISTA VACIA" << endl;
	}
}
 

void ordenar_lista(pnodo &lista)
{
	pnodo i, j, min;
	int aux;
	for(i=lista;i->sig!=NULL;i=i->sig){
		min=i;
		for(j=i->sig;j->sig!=NULL;j=j->sig){
			if(min->dato>j->dato){
				min=j;
			}
		}
		if(min!=i){
			aux=i->dato;
		    i->dato=j->dato;
		    j->dato=aux;
		}
	}
}

for(j=lista;j->sig!=NULL;j=j->sig){
j=i->sig;
 

                        if(j->dato < i->dato){
				min->dato=j->dato;
				min->sig=j->sig;
                        }
 

                        if(j->dato < min->dato){
				min=j;				
                        }
 

               for(j=i->sig;j->sig!=NULL;j=j->sig){
                        if(j->dato < min->dato){
				min=j;				
                        }
              }
 

entero i, j, final
entero min, aux //supongamos que min es un valor entero, que no lo sé, podría incluso ser un string.
nodo n, m, tmp  // necesitaremos 3 nodos...
// n es el nodo siendo examinado en el bucle externo.
// tmp es el nodo siendo examinado en el bucle interno.
// m es el nodo que contiene el valor menor hallado hasta el momento.

final = tamaño de la lista-1
n= lista  // el primer nodo de la lista.

// vamos a marcar el recorrido de los bucles con enteros, 
// cuando te funcione y lo tengas claro, puedes modificarlo para que sea con nodos.

// el último elemento, no precisa ser buscado... 
// cuando se ordenen los previos, el que queda es el mayor, sí o sí, de ahí el -1
bucle i desde 0 hasta final-1 (incrementos de 1) 
     // tomamos el menor aún no ordenado. Empezando por el primero
     min = n.dato  // usamos 'min' por velocidad, y claridad...
     tmp = n  // el primero para el bucle interno (nada más iniciar el bucle, saltamos al siguiente).
     m = n  // ahora este es el menor a superar
     
     // bucle para buscar el menor a partir del 'i'ésimo 
     //este bucle toma el siguiente y termina uno más allá que el bucle externo.
     bucle j = desde i+1 hasta final (incrementos de 1)  
         tmp= tmp.siguiente  
         // el bucle interno, siempre empieza comparando con el siguiente al índice siendo ordenado
         Si (tmp.dato < min)
             m = tmp  //recordamos el nodo menor,  ahora este es el menor a superar
             min = m.dato    // tomamos su valor (para seguir comparando)            
         fin si
     fin bucle

     // ahora el intercambio n x m  (el del bucle externo, por el que contiene el valor menor)
     //   basta cambiar el dato (si el nodo sólo tiene como miembros a 'dato' y 'siguiente' 
     //   pero... si tuviere más o se cambian todos los que proceda o 
     //   se intercambian los nodos entre si al completo, excepto las referencias a otros nodos 
     //     que deberían mantenerse 'siguiente', 'anterior', etc...) 
     aux = n.dato
     n.dato = min
     m.dato = aux

     n = n.siguiente  
fin bucle

void ordenar_lista(pnodo &lista)
{
	pnodo i, j, min;
	int aux;
	for(i=lista;i->sig!=NULL;i=i->sig){
		min=i;
		for(j=i->sig;j!=NULL;j=j->sig){//Esto no entiendo
			if(j->dato<min->dato){
				min=j;
			}
		}
		if(min!=i){
			aux=min->dato;
		    min->dato=i->dato;
		    i->dato=aux;
		}
	}
}

void ordenar_lista(pnodo &lista)
{
	pnodo i, j, min;
	int aux;
	for(i=lista;i->sig!=NULL;i=i->sig){
		min=i;
		for(j=i->sig;j!=NULL;j=j->sig){//Esto no entiendo
			if(j->dato<min->dato){
				min=j;
			}
		}
		if(min!=i){
			aux=i->dato;
		    i->dato=min->dato;
		    min->dato=aux;
		}
	}
}