Cómo implementar la ordenación de inserción recursiva usando una lista vinculada

Gracias por A2A, Neela Ashishkumar

Cuando pensamos en Recursion, solo tenemos que pensar en dos cosas:

  • Condición base
  • Solución a un problema mayor asumiendo que la versión más pequeña de la misma ya está resuelta (porque la más pequeña siempre se resuelve usando la condición base)

Aquí, para el tipo de inserción de N elementos, puede suponer que N-1 están ordenados. Ans luego inserta un elemento en esa matriz atravesándolo. Ahora, suponiendo que la lista es una lista vinculada individualmente y, por lo tanto, no podemos retroceder como en la matriz.

Para la ordenación por inserción en la matriz, simplemente elegimos un elemento y atravesamos el primer elemento para encontrar la posición adecuada. Como no podemos volver al principio, no podemos usar el mismo enfoque. Más bien ordenamos la lista de manera inversa. Por reverso, quiero decir que en orden decreciente de derecha a izquierda, lo que finalmente resulta en un aumento de izquierda a derecha.

Pseudocódigo (la sintaxis es mixta de c ++ y python):

ORDENAR (cabeza):
if (head-> next == NULL): // Condición base de 1 elemento
cabeza de retorno;
descanso = ORDENAR (cabeza-> siguiente);
resultado = descanso;
// Colocando el elemento de cabeza en la posición correcta en el lado derecho y devolviendo la nueva cabeza
datos = cabeza-> datos;
bandera = falso;
prev = cabeza;
while (rest! = NULL && data> rest-> data):
prev = descanso;
descanso = descanso-> siguiente;
bandera = verdadero;
if (bandera == verdadero):
prev-> next = nuevo nodo (datos); // Aquí el nuevo nodo devolverá un nuevo nodo con valor de datos = datos y siguiente = NULL
prev-> next-> next = rest;
resultado de retorno;
más:
head-> next = resultado;
cabeza de retorno;

Espero que esto ayude.

Feliz codificación

Déjame saber si esto no funciona.

Puedo escribir todo el código pero no quiero.
Más bien te ayudaré a entenderlo.
Para cada algoritmo recursivo hay 2 cosas necesarias:

  1. Una condición básica
  2. Convergencia a la condición base

Anote todos los parámetros necesarios para un algoritmo de clasificación de inserción regular. Realice el primer paso del algoritmo y luego, para que esté en recursión, imponga una condición de comprobación, es decir, la condición de la barra; de lo contrario, procesará la matriz secundaria nuevamente.

Estoy escribiendo el algo a continuación.

  1. INS_SORT (ARRAY A, i, j)
  2. SI J = FUERA DE LÍMITE
  3. REGRESO
  4. MÁS
  5. CÓDIGO PARA PRIMER PASO
  6. INS_SORT (ARRAY A, i, j = j + 1)

Creo que esto puede hacer.

Para insertar un nodo N en una lista vinculada L en orden ordenado usando recursividad, puede usar:

insertNode (N, L)
SI L = nulo O N.data <= L.data ENTONCES
N.siguiente = L
VUELTA N
MÁS
L.next = insertNode (N, L.next)
VOLVER L
TERMINARA SI

Para hacer una lista sin clasificar U en una lista ordenada S recursivamente, usaría:

insertSort (U, S)
SI U = nulo ENTONCES
DEVOLUCIONES
MÁS
VOLVER insertNode (U, insertSort (U.next, S)

Esto se llamaría inicialmente con:

S = insertSort (U, nil)

El uso de recursividad mutua como esta haría que la inserción sea bastante lenta, por lo que no se recomienda.