Dividir el programa en funciones pocas veces tiene tanto sentido como en tu caso.
Quieres manejar una lista simple... ¿por qué no crear una función para añadir elementos a la lista, una función para quitar elementos, ...? En vez de reescribir el mismo código 20 veces lo escribes solo una y, si resulta que tienes que modificarlo, todo el programa pasará a a beneficiarse del cambio.
Intuyo que Lista será algo más o menos asi:
Código C:
Ver originaltypedef struct _Lista
{
struct _Lista* sig;
Ventas Vendedor;
} Lista;
Llamar
Lista a esta estructura no sería del todo correcto. Su nombre correcto sería
Nodo y el de
Lista quizás debería parecerse más a:
Código C:
Ver originaltypedef struct
{
Nodo* primero;
int numElementos; // Para simplificar operaciones sobre la lista
} Lista;
¿Por qué? Bueno, el cambio de
Lista a
Nodo parece obvio, realmente la estructura no es una lista sino que representa a un único nodo de la misma. Por otro lado, tener una estructura específica que pueda gestionar el inicio de la lista ayuda a que el programa pueda ganar mucha claridad.
Con esto, las funciones básicas de manipulación podrían quedar tal que:
Código C:
Ver original// Devuelve una lista inicializada.
Lista NuevaLista()
{
Lista toReturn;
toReturn.primero = 0;
toReturn.numElementos = 0;
return toReturn;
}
// Añade un nuevo nodo a la lista
Nodo* NuevoNodo(Lista* lista)
{
Nodo
* nuevo
= (Nodo
*)calloc(1,sizeof(Nodo
));
if( lista->primero== 0 )
lista->primero= nuevo;
else
{
Nodo* ultimo = lista->primero;
while( ultimo->sig != 0)
ultimo = ultimo->sig;
ultimo->sig = nuevo;
}
lista->numElementos++;
return nuevo;
}
// Elimina todos los nodos de la lista
void LimpiarLista(Lista* lista)
{
Nodo* nodo = lista->primero;
while( nodo )
{
Nodo* temp = nodo->sig;
nodo = temp;
}
lista->primero = 0;
lista->numElementos = 0;
}
// Saca un nodo, si existe, de la lista.
// Nota que si la función retorna 1, nodo ya no es válido
int EliminarNodo(Lista* lista, Nodo* nodo)
{
int toReturn = 0;
if( lista->primero == nodo )
{
lista->primero = nodo->sig;
toReturn = 1;
}
else
{
Nodo* anterior = lista->primero;
while( anterior->sig && anterior->sig != nodo )
anterior = anterior->sig;
if( anterior->sig )
{
anterior->sig = nodo->sig;
toReturn = 1;
}
}
if( toReturn )
{
lista->numElementos--;
}
return toReturn;
}
Con este catálogo la utilización de la lista se simplifica enormemente. Al catálogo actual habría que ir añadiendo otras funciones de interés en función de la naturaleza de la lista y de los requisitos de la aplicación... por ejemplo la posibilidad de ordenar la lista:
Código C++:
Ver originalvoid OrdenarPorVentasMayor(Lista* lista)
{
// Estructura auxiliar para ordenar
// El último nodo será 0 para simplificar el proceso
Nodo
** nodos
= (Nodo
**)calloc(lista
->numElementos
+1,sizeof(Nodo
*));
// Se copian los nodos de la lista a nuestro arreglo
Nodo* nodo = lista->primero;
int index = 0;
while(nodo)
{
nodos[index] = nodo;
index++;
nodo = nodo->sig;
}
// Se ordenan los nodos
for (int i = 0 ; i < lista->numElementos-1; i++)
{
for (int j = 0 ; j < lista->numElementos - i - 1; j++)
{
if ( nodos[j]->Vendedor.contadorventas < nodos[j+1]->Vendedor.contadorventas)
{
Nodo* swap = nodos[j];
nodos[j] = nodos[j+1];
nodos[j+1] = swap;
}
}
}
// Se reconstruye la lista
lista->primero = nodos[0];
for( int i=0; i<lista->numElementos; i++)
{
// Como el último nodo es NULL, el último nodo real de la lista acabará apuntando a NULL automáticamente
nodos[i]->sig = nodos[i+1];
}
}
Una forma muy sencilla de ordenar una lista enlazada (o doblemente enlazada) consiste en crear un vector de punteros a nodos. Se ordenan los punteros en dicho vector y, finalmente, se recorre ese vector ordenado para actualizar los enlaces entre los nodos. En el caso de una lista simple se puede crear la lista con un elemento "fantasma" al final para que el último nodo de la lista se quede apuntando siempre a null.
Y, como te ha dicho Instru, el código cuanto más sencillo, mejor.
Un saludo.
. 
.
