¿Es posible escribir un método que muestre todos los elementos en una lista enlazada circular?

CIR_LL.CPP [Programa completo de listas circulares vinculadas]
show () es la función de visualización.

#include
#include
#include

//declaración

• ¿Qué algoritmos de Machine Learning pueden usarse para el aprendizaje supervisado incremental?
• ¿Se puede implementar la imaginación usando algoritmos? ¿Hay algo que no podamos explicar a través de un algoritmo, incluso en el futuro?
• ¿Alguien puede dar el algoritmo detallado del algoritmo mejorado de segunda oportunidad?
• ¿Ha habido algún trabajo teórico que delinee qué clase de algoritmos pueden y no pueden mapearse para mapear / reducir?
• ¿Por qué no necesito conocer algoritmos para lenguajes de programación modernos como Java o Python?

typedef struct queLL
{
datos int;
struct queLL * link;
}Nodo;
Nodo * s = NULL; // comienzo

Nodo * getN ()
{
return ((Node *) malloc (sizeof (Node)));
}

anular add (); // agregar al final
show nulo ();
anular create ();
nulo del (); // del al final
anular addS (); // comenzar a agregar
nulo addB (); // agregar entre
nulo delS (); // del inicio
nulo delB (); // del between
nulo rev (); // lista circular inversa

int cnt = 0; // contador para adición / eliminación en b / w

vacío principal()
{
clrscr (); int ch; // elección
int e = 0; // Estilo de menú
cout << "—— Cola particular usando la lista vinculada ——-";
hacer
{
si (e == 0)
{
cout << "\ n \ n \ t1. Crear \ n \ t2. Agregar al FINAL";
cout << "\ n \ t3. Mostrar \ n \ t4. Eliminar al FIN \ n \ t5. Salir";
cout << "\ n \ t6. Agregar en START \ n \ t7. Eliminar de START \ n \ t8. Agregar en medio";
cout << "\ n \ t9. Eliminar en el medio";
cout << "\ n \ t10. Activar / Mini / Desactivar menú \ n \ t11. Lista inversa";
}
si (e == 1)
{
cout << "\ n \ n1. Crear | 2. Agregar al final | 3. Mostrar | 4. Eliminar al final | 5. Salir";
cout << "\ n6. Agregar al inicio | 7. Eliminar del inicio | 8. Agregar entre" ";
cout << "\ n9. Eliminar entre | 10. Activar / Mini / Desactivar menú | 11. Lista inversa";
}
cout <> ch;
interruptor (ch)
{
caso 1: crear (); descanso;
caso 2: agregar (); descanso;
caso 3: show (); descanso;
caso 4: del (); descanso;
caso 5: salida (0); descanso;
caso 6: addS (); descanso;
caso 7: delS (); descanso;
caso 8: addB (); descanso;
caso 9: delB (); descanso;
caso 10: clrscr (); e = (e + 1)% 3; descanso;
caso 11: rev (); descanso;
predeterminado: cout << "\ n¡Elección incorrecta!";
}
} while (ch! = 5);
}
// * t, * t1 son variables temporales de desplazamiento. * f se usa para liberar
// memoria donde sea necesario. * a para agregar más elementos.
vacío crear ()
{
Nodo * t = getN (); char c = ‘y’;
s = t;
mientras que (1)
{
cout <> t-> datos; cnt ++;
cout <> c;
if (c == ‘n’ || c == ‘N’)
{
t-> enlace = s; // circular, de lo contrario t-> link = NULL
descanso;
}
t-> enlace = getN ();
t = t-> enlace;
}
}

espectáculo vacío ()
{
clrscr ();
if (s == NULL) cout << "\ nERROR: vacío!";
más
{
Nodo * t = s;
cout << "\ nLista enlazada circular es:";

hacer
{
cout < datos <“;
t = t-> enlace;
} while (t! = s);
cout << "\ b" << char (175) << char (25); // probablemente tuvo tiempo libre
gotoxi (26,3);
cout << char (24) << char (174) << "-";
getch ();
clrscr ();
}

}

vacío del ()
{
if (s == NULL) cout << "\ nERROR: vacío!";
más
{
Nodo * t = s;
si (t-> enlace == s)
{
cout << "\ nEliminado:" < datos; cnt–;
libre (t);
s = NULL;
}
más
{
Nodo * t1 = t;
t = t-> enlace;
while (t-> link! = s)
{
t = t-> enlace;
t1 = t1-> enlace;
}
cout << "\ nEliminado:" < datos; cnt–;
t1-> enlace = s;
libre (t);
}
}
}

void add ()
{
if (s == NULL)
{
Nodo * t = getN ();
s = t;
cout <> t-> datos; cnt ++;
t-> enlace = s;
}
más
{
Nodo * t = s;
while (t-> link! = s)
{
t = t-> enlace;
}
Nodo * a = getN ();
cout <> a-> datos; cnt ++;
a-> enlace = s; t-> enlace = a;
}
}

addS vacíos ()
{
if (s == NULL)
{
Nodo * t = getN ();
cout <> t-> datos; cnt ++;
s = t; t-> enlace = s;
}
más
{
Nodo * t1 = s;
while (t1-> link! = s)
{
t1 = t1-> enlace;
}
Nodo * t = getN ();
cout <> t-> datos; cnt ++;
t-> enlace = s; s = t; t1-> enlace = s;
}
}

nulo delS ()
{
if (s == NULL) cout << "ERROR: Empty!";
más
{
Nodo * t = s;
si (t-> enlace == s)
{
cout << "Eliminado:" < datos; cnt–;
s = NULL; libre (t);
}
más
{
Nodo * t = s;
while (t-> link! = s)
{
t = t-> enlace;
}
Nodo * t1 = s;
s = s-> enlace;
t-> enlace = s;
cout << "\ nEliminado:" < datos; cnt–;
libre (t1);
}
}
}

nulo addB ()
{
cout <> l;
if (l> (cnt + 1) || l <0) cout << "\ nOut of Bounds!";
más si (l == 0) addS ();
más si (l == cnt) add ();
más
{
Nodo * t = s;
para (int i = 0; i <l-1; i ++)
{
t = t-> enlace;
}
Nodo * t1 = t-> enlace;
Nodo * a = getN ();
cout <> a-> datos;
t-> enlace = a; a-> enlace = t1; cnt ++;
}
}

nulo delB ()
{
if (s == NULL) cout << "\ nEmpty!";
más
{
cout <> l;
if (l> (cnt + 1) || l <= 0) cout << "\ nOut of Bounds!";
más si (l == 1) delS ();
más si (l == cnt) del ();
más
{
Nodo * t = s;
para (int i = 0; i <l-2; i ++)
{
t = t-> enlace;
}
Nodo * t1 = t-> enlace;
cout << "\ nEliminado:" < datos; cnt–;
Nodo * f = t1; t1 = t1-> enlace; t-> enlace = t1;
libre (f);
}
}
}

nulo rev ()
{
Nodo * cur = s-> link, * prev = s, * next = NULL; s-> link = NULL;

while (cur! = NULL)
{
siguiente = cur-> enlace;
cur-> link = prev;
prev = cur;
cur = siguiente;
}
s = anterior-> enlace;
}