Imprimir lista vinculada en C ++

Cuando se trata de almacenar dinámicamente elementos de datos, las listas vinculadas son similares a una matriz. Una matriz es una estructura de datos lineal que almacena todos los elementos de datos, lo que nos permite transferir los elementos de la matriz en una operación continua. Mientras que los elementos de datos en la lista vinculada no se mantienen en ubicaciones de memoria continua cuando se almacenan. Hay el punto de partida en la lista vinculada que se llama cabezal y el punto final se llama la cola de la lista vinculada en el lenguaje de programación C ++. En una lista vinculada, hay nodos que almacenan objetos de datos en ella. El nodo tiene dos partes: la parte contiene el objeto de datos en sí mismo y la segunda parte contiene el puntero hacia el nodo después de él. El nodo final de la lista vinculada contiene el puntero nulo.

Estamos utilizando una lista vinculada cuando tenemos una matriz para almacenar los datos porque en las matrices tenemos que decir la longitud de la matriz durante la declaración de la matriz. Pero en las listas vinculadas, el tamaño ya no es un problema. La longitud de la lista vinculada se expandirá según lo requiera el programa, pero la lista está limitada por la capacidad de la memoria que está disponible. La lista vinculada puede realizar múltiples operaciones en el lenguaje C ++ que son: Inserción, deleción, transversal, búsqueda y operaciones de clasificación. Para comprender estas operaciones de la lista de enlaces, implementemos el ejemplo y comprendamos cómo funciona una lista vinculada en el lenguaje de programación C ++. También exploramos cómo funcionan estas operaciones en la lista vinculada.

Ejemplo:

Comencemos ahora a desarrollar el ejemplo de la lista vinculada del lenguaje de programación C ++. Inicie el compilador y comience a escribir código para poner en práctica el ejemplo. Debemos incluir el archivo de encabezado después de ejecutar el traductor para que sea simple y fácil de acceder a los métodos incorporados, las clases y otros componentes que deseamos incluir en el programa de lenguaje de programación C ++.

#incluir
#incluir
usando el espacio de nombres STD;

El paquete "iOStream" es el primer paquete fundamental en C ++ y es utilizado por todos los programas porque permite a los usuarios proporcionar salida de entrada y vista. El segundo encabezado de biblioteca estándar "Stdlib.H "proporciona rutinas confiables y efectivas para la asignación de la memoria dinámicamente a los programadores C ++. El signo "#" instruye al intérprete que busque los paquetes, seguido de la palabra clave "incluyendo", diciéndole que incorpore la biblioteca. Finalmente, el nombre de la biblioteca está escrito en los tokens "". La última oración, "Uso de Namespace STD", es necesaria para proporcionar contexto para el código.

Inicializando la estructura

A continuación, crearemos la estructura del nombre "nodo" para que formemos el nodo de la lista vinculada. Después de crear el nodo, declararemos las partes del nodo en la estructura. La primera parte del nodo es donde almacenamos los elementos de datos. Entonces, hemos declarado una variable de tipo entero "información" para almacenar los elementos de datos. La siguiente parte es una variable de puntero "Follownode" que moverá el puntero hacia el siguiente Follownode en la lista vinculada. Los detalles son los siguientes:

nodo

int info;
struct nodo* follownode;
;

Insertar elementos de datos en la lista vinculada

Hemos creado múltiples funciones para poder insertar los elementos de datos en la lista vinculada que queremos crear en el lenguaje de programación C ++.

función beg_insert ():

Hemos creado una función definida por el usuario en el lenguaje de programación C ++ que es la función Beg_insert (). Como su nombre indica, utilizaremos esta función para insertar los datos al comienzo de la lista vinculada. La función beg_insert () toma dos argumentos que son "head_info", que es el puntero del puntero de la cabeza de la lista vinculada y el segundo argumento es "new_info", que es la fecha del nuevo Follownode que se insertará. A continuación, la función ha creado un "Cur_node" de tipo "nodo" utilizando la función MALLOC (). El "nodo CUR" se inicializa luego con el parámetro "nueva información" y su puntero se establece en la cabeza de la lista conectada. Usando la referencia de "Información de la cabeza", la cabeza de la lista vinculada se enumera inicialmente en el "nodo CUR".

void beg_insert (struct nodo ** head_info, int new_info)

struct node* cur_node = (nodo struct*) malloc (sizeOf (nodo struct));
cur_node-> info = new_info;
cur_node-> follownode = (*head_info);
(*head_info) = cur_node;

función mid_insert ():

Ahora, hemos creado otra función para ingresar los elementos de datos en el medio de la lista que me gusta, que es la función mid_insert (). En la función Mid (), tenemos que tomar dos argumentos que son "pre_node", que es el puntero del tipo "nodo", y "new_info", que es la variable que almacena los nuevos datos en sí mismo del tipo entero. Hemos usado la instrucción "IF" para verificar el "pre_node si es nulo o no en el cuerpo de la función, hemos declarado un" Cur_node "y almacenamos el" New_info "en él en él. Luego creamos un puntero "siguiente" del "new_info" que apunta hacia el siguiente nodo del "pre_node".

void mid_insert (struct node* pre_node, int new_info)

if (pre_node == null)

cout << "The Previous Node Can't be NULL";
devolver;

struct node* cur_node = (nodo struct*) malloc (sizeOf (nodo struct));
cur_node-> info = new_info;
Cur_node-> follownode = pre_node-> follownode;
pre_node-> follownode = cur_node;

Función end_insert ():

Hemos creado esta función para que podamos ingresar los elementos de datos al final de la lista vinculada. Hemos declarado los mismos argumentos que hemos declarado en la función Beg_insert (). Esta función primero verifica si la lista está vacía o no. Ponga la "nueva información" al comienzo de la lista y devuélvala si la lista también era nula. Si no es nulo, el procedimiento continuará a través de la lista hasta que llegue al nodo "último nodo". Luego se agrega la "nueva información" como el nodo del "último nodo" al final de la lista.

void end_insert (struct nodo ** head_info, int new_info)

struct node* cur_node = (nodo struct*) malloc (sizeOf (nodo struct));
struct node * last_node = * head_info;
cur_node-> info = new_info;
cur_node-> follownode = null;
if (*head_info == nulo)

*head_info = cur_node;
devolver;

while (last_node-> follownode != Nulo)

last_node = last_node-> follownode;
last_node-> follownode = cur_node;
devolver;

Sacar un nodo de una lista vinculada

Para eliminar los nodos actuales de la lista vinculada, ahora hemos creado un nuevo método llamado nodo delete (). Primero determina si el nodo principal tiene el nuevo_key que debe borrarse. Si es así, se actualiza la referencia de la cabeza al Follownode. Usando un bucle, ubicará el nodo que contiene el New_Key a destruir. Cuando se descubre un nodo, el nodo "pre" actualiza el puntero Follownode del nodo que se destruirá para que pueda eliminarse sin ser visto. Finalmente, la función libre () se usa para liberar el almacenamiento.

void delete_node (struct node ** head_info, int new_key)

struct nodo *temp_var = *head_info, *pre;
if (temp_var != Null && temp_var-> info == new_key)

*head_info = temp_var-> follownode;
gratis (temp_var);
devolver;

while (temp_var != NULL && TEMP_VAR-> INFO != new_key)

pre = temp_var;
TEMP_VAR = TEMP_VAR-> FOLLOWNODE;

if (temp_var == nulo)

devolver;

pre-> follownode = temp_var-> follownode;
gratis (temp_var);

Busque el nodo en la lista vinculada

La búsqueda de funciones () toma dos argumentos, que son el puntero al "head_info" de la lista vinculada y el "new_key" que se debe buscar. La función atraviesa la lista vinculada y verifica si los datos del nodo actual coinciden con el "New_Key". Si los datos del nodo "actual" coinciden con el "new_key", la función devuelve verdaderas. Si los datos del nodo "actual" no coinciden con el "New_Key", la función se mueve al Follownode. Si el nodo "actual" se vuelve nulo, la función devuelve falso.

Bool Search (struct nodo ** head_info, int new_key)

struct node * curtion = * head_info;
mientras (actual != Nulo)

if (actual-> info == new_key)

devolver verdadero;

actual = actual-> follownode;

falso retorno;

Ordenar los componentes del nodo en la lista vinculada

En la programación de C ++, el método sort () se usa para organizar a los miembros en la lista vinculada en orden creciente. Primero, se determina si la referencia de "Información de la cabeza" es nula. Si es así, regresamos. Después de eso, la lista se repite varias veces hasta la terminación del bucle. Comprobación de si hay más información presente en el nodo "actual", entonces en el nodo "índice" viene el siguiente. Si es así, intercambiamos los datos entre los dos nodos. El nodo "índice" se transfiere al Follownode. El procedimiento se repite hasta la finalización de la lista.

Sorteo vacío (nodo struct ** head_info)

struct node *current = *head_info, *index = null;
int temp_var;
if (head_info == null)

devolver;

demás

mientras (actual != Nulo)

índice = actual-> follownode;
mientras (índice != Nulo)

if (actual-> info> índice-> información)

temp_var = actual-> info;
actual-> info = index-> ​​info;
index-> ​​info = temp_var;

índice = index-> ​​follownode;

actual = actual-> follownode;

Muestra el nodo en la lista vinculada

La función display () toma un puntero al cabezal de la lista vinculada como parámetro. Después de eso, pasa por la lista y muestra la información de cada nodo. Cuando llega a la finalización de la lista, se detiene.

visualización vacía (nodo estructural* nodo)

mientras (nodo != Nulo)
GRAMO
cout << node->información << " ";
nodo = nodo-> follownode;

Llamar a las funciones en la función Main ()

Hemos escrito la función Main () para que podamos comenzar a escribir el código del controlador del programa en el cuerpo de la función Main (). Primero, el puntero "head_val" se inicializa a nulo del tipo "nodo". Luego, llamamos a las funciones de inserción que hemos creado a nivel mundial y definimos cada función de insertar y pasamos el valor en ella. Para mostrar la lista vinculada en la ventana de la consola del usuario, hemos llamado a una función de pantalla definida por el usuario (). Llame a la clasificación () para que podamos arrainarse los datos en la lista vinculada. Para eliminar el nodo de la lista vinculada, hemos llamado a la función delete_node () y hayan pasado los elementos de datos que queremos eliminar. Si queremos encontrar algún elemento del nodo, hemos llamado a la función de búsqueda () y pasamos el elemento en él.

int main ()

struct node* head_val = null;
Beg_insert (& Head_val, 34);
Beg_insert (& Head_val, 10);
end_insert (& head_val, 48);
mid_insert (head_val-> follownode, 72);
cout << "*---Implementation of Linked List in C++---*" << endl;
cout << "\nThe Input Linked list is: ";
Display (head_val);
sort (& head_val);
cout << "\n\nAfter Sorting the Input List: ";
Display (head_val);
cout << "\nAfter deleting an element: ";
delete_node (& head_val, 48);
Display (head_val);
Beg_insert (& Head_val, 63);
Beg_insert (& Head_val, 84);
end_insert (& head_val, 11);
mid_insert (head_val-> follownode, 100);
cout << "\n\nThe Updated Linked list is: ";
Display (head_val);
sort (& head_val);
cout << "\nAfter Sorting the Input List: ";
Display (head_val);
int find_data;
cout << "\n\nEnter the element which you want to find? ";
cin >> find_data;
if (buscar (& head_val, find_data))

cout << "The element " << find_data << " is found… ";

demás

cout << "The element " << find_data << " is not found… ";

A continuación se muestra el resultado del lenguaje de programación C ++ del escenario de la compilación anterior.

Conclusión

La lista vinculada en el lenguaje de programación C ++ y la distinción entre una matriz y una lista vinculada se cubrieron en este artículo. Hemos hablado sobre las diversas operaciones de la lista vinculada. Primero construimos un escenario de lista vinculada, luego construimos cada operación en la ilustración con una descripción completa de cada línea de código C ++.