Lista circular vinculada en C ++

Podemos poner elementos en la lista Circular Linked desde cualquier lugar de la lista; Sin embargo, no podemos insertar elementos en la matriz desde cualquier lugar de la lista, ya que está en memoria contigua. El último elemento en una lista circular vinculada mantiene la dirección del siguiente elemento, mientras que el último elemento mantiene la dirección del primer elemento. La cadena circular está formada por los elementos que se refieren entre sí en un patrón circular.

Como la lista Circular Linked tiene un tamaño dinámico, la memoria se puede asignar solo cuando sea necesario. El artículo demostrará la lista Circular Linked con las ilustraciones del programa C ++ en C++.

Aplicación de la lista Circular Linked

Una lista circular vinculada es aquella en la que todos los nodos están conectados en un círculo. No hay un elemento nulo en la lista de enlaces circulares. Un punto de partida puede ser cualquier nodo. A partir de cualquier lugar de la lista, podemos atravesar toda la lista. Todo lo que tenemos que hacer ahora es esperar hasta que se alcance el primer nodo nuevamente. Allí tenemos algunas aplicaciones de una lista circular vinculada de la siguiente manera:

1. Nuestras computadoras personales, que ejecutan varias aplicaciones, son un ejemplo de cómo se utiliza la lista circular vinculada en la vida real. Todas las aplicaciones en ejecución se almacenan en una lista circular vinculada, y el sistema operativo le asigna a cada uno una ranura de tiempo determinada para ejecutar. El sistema operativo continúa pasando por la lista vinculada hasta que se ejecutan todos los programas.
2. Los juegos multijugador son otro excelente ejemplo. Todos los jugadores se almacenan en una lista circular vinculada, con el puntero avanzando cuando la oportunidad de cada jugador expira.
3. La cola circular también se puede crear utilizando una lista circular vinculada. Debemos retener ambos consejos, delanteros y traseros, en la memoria en todo momento en una cola, pero solo se necesita un puntero en una lista circular vinculada.

Ejemplo 1: Crear lista circular vinculada transversal en c++

La única diferencia es que en una lista circular vinculada, el nodo en la última posición tendrá su próximo enlace al jefe de la lista, mientras que, en una lista lineal vinculada, el último nodo tendría su próximo punto a la parte inferior de la Lista. La implementación del código de transversal de la lista vinculada circular en C ++ se muestra a continuación.

En el primer paso, hemos definido una clase como "nodo", en el que hemos declarado una variable int como "mydata". La variable "MyData" son los datos del nodo. El puntero también se declara en esta clase como "Siguiente" para el puntero al siguiente nodo en la lista Circular Linked Linked.

Después de la clase "Nodo", tenemos una función llamada "Push", que inserta el nodo al comienzo de la lista Circular Linked Linked. Definimos el constructor, que pasa la referencia del puntero Head_Node de la clase "nodo" y la variable "myData" como parámetro. El nuevo puntero se crea como "myPTR", que ha llamado y asignado el "nodo".

Entonces, el puntero de temperatura se declara como "temperatura", que tiene la cabeza_node. Hay consejos como "Ptr1" y "Ptr2" que se llaman "MyData" y puntero "Next" y toman sus direcciones. Después de eso, tenemos una declaración IF en la que solo hay head_node, y se mantiene nula. Si la lista Circular Linked es nula, agregue el siguiente al último nodo con la ayuda de un bucle de tiempo. De lo contrario, la declaración delse se ejecutará en la que el jefe apunta al primer nodo de la lista.

Luego, hemos creado otra función como "lista de visualización", y en el constructor de esta función, acabamos de pasar el cabezal de nodo de la lista de enlaces circulares. La función mostrará los nodos en una lista circular vinculada a través de un bucle do-while después de la instrucción if, que tiene la condición de que el cabezal del nodo no debe ser igual a NULL.

Finalmente, existe el método principal, que probará la implementación descrita anteriormente. El cabezal del puntero del "nodo" de la clase se ha establecido en "nulo" en el método principal. Luego, agregue los datos a la lista vinculada con la ayuda del método push (). La "Cabeza" se pasa a la función "DisplayList", que mostrará la lista de vinculación circular.

#incluir
usando el espacio de nombres STD;
nodo de clase

público:
int mydata;
Nodo *siguiente;
;
Void Push (nodo ** head_node, int myData)

Nodo *myPtr1 = new Node ();
Nodo *temp = *head_node;
MyPtr1-> myData = myData;
Myptr1-> next = *head_node;
if (*head_node != Nulo)

mientras (temp-> siguiente != *head_node)
temp = temp-> next;
temp-> next = myPtr1;

demás
Myptr1-> next = myPtr1;
*head_node = myPtr1;

Void DisplayList (nodo *Head)

Nodo *temp = head;
if (cabeza != Nulo)

hacer

cout
mientras (temperatura != cabeza);


int main ()

Nodo *head = null;
Push (& Head, 2001);
Push (& Head, 2015);
Push (y Head, 2006);
Push (& Head, 2022);
cout<< "Circular Linked List:\n ";
DisplayList (cabeza);
cout<< "\n ";
regresar 0;

La lista circular vinculada implementada en la salida del código anterior se muestra en la siguiente imagen.

Ejemplo2: divida la lista circular vinculada en dos mitades en c++

El siguiente programa hace que dividir una lista circular vinculada en dos partes sea posible. Veamos la implementación de cómo dividimos la lista circular vinculada en c++.

Primero, tenemos un "nodo" de clase donde hemos definido una variable "elementos" y el puntero "siguiente" del nodo. Los miembros de la clase "nodo" son públicos en este programa. Luego, creamos una función llamada "Halvelist" en la que dividimos la lista desde el principio con la cabeza en dos listas. El cabezal1_node y la cabeza2_node son referencias a los dos nodos de la cabeza de las listas vinculadas resultantes.

En la función, hemos declarado dos punteros, "S_PTR" y el "F_PTR", que tiene el jefe de la lista vinculada. Si la instrucción if se usa para el nodo principal que contiene un valor nulo, entonces tenemos un bucle de tiempo que establece que f_ptr-> a continuación se convierte en cabeza si la lista circular tiene nodos impares, y f_ptr-> next-> a continuación se convierte en la cabeza si el La lista contiene nodos incluso.

Después del bucle While, hemos usado nuevamente la instrucción if en la que la condición es "Si la lista contiene un número incluso de elementos, F_PTR debe moverse y establecer el puntero de la primera mitad de la primera". En la siguiente instrucción IF, hemos establecido el cabezal2_node en la segunda mitad de la lista vinculada.

Hemos asignado el S_PTR-> al lado del F_PTR-> Siguiente para hacer el segundo medio circular de la lista, y luego S_PTR-> se mantiene igual a la cabeza de la lista y hace que el primer medio círculo.

La segunda función se crea como "Push", que se utiliza para insertar un nodo al inicio de una lista circular vinculada con esta función. En la función, la condición implica si el nodo head_node de la lista de enlace circular no es nula, luego configure junto al último nodo. La tercera función, "DisplayList", se genera para que se muestre la lista de vinculación circular.

Luego, tenemos la función principal, donde hemos inicializado la cabeza, la cabeza1_node y la cabeza2_node vacía. El método Push se usa para insertar los valores en la lista vinculada, y a través del comando Cout, se mostrará la lista de enlace circular y la lista de enlace circular dividida.

#incluir
usando el espacio de nombres STD;
clase mynode

público:
It ítems;
MyNode *Siguiente;
;
void halvelist (mynode *head, mynode ** head1_node, mynode ** head2_node)

MyNode *s_ptr = head;
MyNode *f_ptr = head;
if (head == null)
devolver;
while (f_ptr-> Siguiente != cabeza &&
F_PTR-> NEXT-> Siguiente != Cabeza)

f_ptr = f_ptr-> next-> next;
S_PTR = S_PTR-> NEXT;

if (f_ptr-> next-> next == head)
F_PTR = F_PTR-> NEXT;
*head1_node = head;
if (Head-> Siguiente != Cabeza)
*head2_node = s_ptr-> next;
f_ptr-> next = s_ptr-> next;
s_ptr-> next = head;

void push (mynode ** head_node, int items)

MyNode *newPtr = new myNode ();
MyNode *temp = *head_node;
Newptr-> elementos = elementos;
Newptr-> next = *head_node;
if (*head_node != Nulo)

mientras (temp-> siguiente != *head_node)
temp = temp-> next;
temp-> next = newPtr;

demás
Newptr-> next = newPtr; / *Para el primer mynode */
*head_node = newptr;

Void DisplayList (MyNode *Head)

MyNode *temp = head;
if (cabeza != Nulo)

cout<hacer
cout while (temperatura != cabeza);


int main ()

int myListize, i;
MyNode *head = null;
MyNode *head1 = null;
MyNode *head2 = null;
empuje (y cabeza, 10);
Push (& Head, 90);
empuje (y cabeza, 40);
Push (& Head, 70);
cout<< "Circular Linked List";
DisplayList (cabeza);
Halvelist (Head, & Head1, y Head2);
cout<< "\nFirst Halve Circular Linked List";
DisplayList (Head1);
cout<< "\nSecond Halve Circular Linked List";
DisplayList (Head2);
regresar 0;

Aquí tenemos la salida de la lista Circular Circular original, la salida de la primera lista vinculada de medio circular y la segunda mitad de la lista Circular Linked Linked.

Ejemplo 3: Ordenar la lista Circular Linked en C++

En el primer paso, tenemos una clase "nodelista", que contiene variables y punteros miembros en la clase. Luego, hemos creado una función "sortinsertion", que inserta un nuevo nodo en una lista ordenada. Esta función requiere un puntero al nodo de la cabeza porque puede cambiar la cabeza de la lista vinculada de entrada.

Después de eso, tenemos una declaración IF para nodelist, que contiene solo un nodo en él. El punto de cabeza_node al nuevo nodo. En la declaración de lo contrario, hemos asignado los datos del nodelist a la corriente.

Aquí, se agrega un nuevo nodo antes del nodo principal. El bloque if-else tiene un bucle de tiempo que tiene una condición; Si el valor es menor que el valor de la cabeza, el siguiente o último nodo debe cambiarse. El bucle de rulos simplemente identificará el nodo antes del punto de inserción.

Después de eso, hicimos una nueva_nodelista, el siguiente nodo que localiza el siguiente nodo del puntero. Luego, actual-> Siguiente, tenemos que cambiar la ubicación del puntero a la siguiente. Para imprimir los nodos de la lista vinculada, hemos llamado a una función "ShowList".

Al final, tenemos la función principal en la que hemos inicializado una matriz e iterado sobre la matriz especificada, que será una matriz ordenada.

#incluir
usando el espacio de nombres STD;
clase Nodelista

público:
valores int;
Nodelist *Siguiente;
;
void sortinSertion (nodelist ** head_node, nodelist* new_nodeList)

Nodelist * actual = * head_node;
if (corriente == nulo)

new_nodeList-> next = new_nodeList;
*head_node = new_nodeList;

else if (actual-> valores> = new_nodeList-> valores)

while (actual-> siguiente != *head_node)
corriente = corriente-> Next;
actual-> next = new_nodeList;
new_nodelist-> next = *head_node;
*head_node = new_nodeList;

demás

while (actual-> siguiente!= *head_node &&
valores de corriente-> next->)
corriente = corriente-> Next;
new_nodeList-> next = current-> next;
actual-> next = new_nodeList;


Void ShowList (nodelist *begin)

Nodelist *temp;
Si (comenzar != Nulo)

temp = begin;
hacer
cout while (temperatura != comenzar);


int main ()

int myarr [] = 31, 5, 23, 99, 30;
int list_size, i;
Nodelist *begin = null;
Nodelist *temp;
para (i = 0; ivalues ​​= myarr [i];
Sortinsertion (& begin, temp);

cout<<"Sorted Circular Linked List:\n";
ShowList (Begin);
cout<<"\n";
regresar 0;

La lista de enlace circular ordenada se muestra en la siguiente pantalla de Ubuntu.

Conclusión

Esto termina nuestra discusión sobre cómo insertar, dividir y clasificar los nodos en una lista circular vinculada en C++. Una lista circular vinculada se usa en muchas aplicaciones que exigen mucha flexibilidad. Espero que esto lo ayude a eliminar la ambigüedad relacionada con la lista circular vinculada en C++.