How to order with insert sort a linked list c ++

case 1:
    cout << "Codigo: ";
    cin >> codigoDistribuidora;
    nuevo.guardaNombre(codigoDistribuidora);
    cout << "Nombre: ";
    cin.ignore();
    getline(cin, nombreDistribuidora);
    nuevo.guardaNombre(nombreDistribuidora);
    cout << "Domicilio: ";
    getline(cin, domicilioDistribuidora);
    nuevo.guardaNombre(domicilioDistribuidora);
    cout << "Telefono: ";
    cin >> telefonoDistribuidora;
    nuevo.guardaNombre(telefonoDistribuidora);
    cout << "Nombre del gerente: ";
    cin.ignore();
    getline(cin, nombreGerente);
    nuevo.guardaNombre(nombreGerente);
    l.insertaInicio(nuevo);
    break;

The previous code should go in a separate function. Apart from greatly improving the readability of the code, it must be borne in mind that the switch sentences can be quite dangerous if a break disappears or if the code sneaks prematurely. It is highly recommended to have case as simple as possible.

On the other hand, and given that you do not include the full implementation of Lista , I mention that in the insertaInicio function you can have a problem:

void Lista::insertaInicio(Distribuidora dato) {
  Nodo *tmp = new Nodo;
  Nodo *aux = inicio; // <<--- AQUI!!!
}

What happens if the list is empty and, as a result, inicio points to nullptr ? Since you are making a copy of inicio in aux it is not valid to modify the address pointed to by aux , since in that case inicio will not find out.

Well, speaking of your problem, what you have to do is find at what point of the list you have to insert the new element. In this way the list will ALWAYS be ordered. What you need is to determine the way to sort the list:

• By distributor code?
• By name of distributor?
• By the phone number?

If we assume that you choose the first option the algorithm and that the order is increasing, to determine the position of the new element would be the following:

Said with a code could be something like this:

Nodo* nuevo = new Nodo;
// falta la inicialización del nodo

if( inicio == nullptr )
  inicio = nuevo;
else
{
  Nodo* previo = inicio;

  Nodo* siguiente = inicio->sig;

  while ( siguiente != nullptr && siguiente->damecodigoDistribuidora() < nuevo->damecodigoDistribuidora() )
  {
    previo = siguiente;
    siguiente = previo->sig;
  }

  // Podemos llegar a este punto desde dos caminos diferentes
  // 1. El código de siguiente es mayor que el del nuevo elemento
  // 2. Hemos llegado al final de la lista
  // En cualquier caso la operativa es exactamente la misma:
  // Insertar el nodo entre previo y siguiente
  previo->sig = nodo;
  nodo->sig = siguiente;
}

Greetings.

Apparently you are working with a list just linked which makes the insertion process orderly slightly more complicated.

In this type of list, the ordered insertion process is divided into:

Nodo *anterior = inicio;
Nodo *punto_insercion = anterior->sig;

while (punto_insercion  && (punto_insercion->dato > dato))
{
    anterior = punto_insercion;
    punto_insercion = punto_insercion->sig;
}

// Una vez superado el bucle, punto_insercion apunta
// al nodo inmediatamente superior al actual o al tope

anterior->sig = new Nodo(dato, punto_insercion);

In the example code above I am assuming:

• The list is not empty.
• Nodo has a constructor that receives dato and the node to point to.
• The dato to compare has a greater operator-than > .

Keep in mind that what I have written is a guide, you must adapt it to your needs and keep in mind that I have not tried the pseudo-code