Modificar el contenido de lista enlazada utilizando el programa C ++

Modificación de una lista enlazada : En este artículo, vamos a aprender cómo modificar el contenido de una lista enlazada mediante el programa C ++?

Planteamiento del problema:

Dada una lista enlazada, que modificó esa lista vinculada de tal manera que los elementos de la primera mitad de la lista enlazada son la diferencia del primer nodo de la última nodo y nodo siguiente es la diferencia del segundo nodo al segundo nodo pasado y continúa.

Ejemplo:

    Input: 
4 → 5 → 9 → 3 → 8 → 1 → 2 → 5
Output:
-1 → 3 → 8 → -5 → 8 → 1 → 2 → 5
Input:
6 → 5 → 4 → 9 → 1 → 2 → 7
Output:
-1 → 3 → 3 → 9 → 1 → 2 → 7

Algoritmo:

Para resolver el problema, podemos seguir este algoritmo:

  1. En primer lugar, nos encontramos con el punto medio de esa lista enlazada y tomar una copia de esa .
  2. Luego dividimos esa lista enlazada desde el punto medio.
  3. Luego revertir la segunda parte de esa lista enlazada.
  4. A continuación se calcula la diferencia del primer nodo de la lista enlazada de dos y poner el valor a la lista enlazada originales.
  5. class para encontrar la diferencia hasta que vayamos al último nodo del segundo elemento.

implementación en C ++:

#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
node* next;
};
void print(node*);
//Create a new node
struct node* create_node(int x)
{
struct node* temp = new node;
temp -> data = x;
temp -> next = NULL;
return temp;
}
//Enter the node into the linked list
void push(node** head, int x)
{
struct node* store = create_node(x);
if (*head == NULL) {
*head = store;
return;
}
struct node* temp = *head;
while (temp -> next) {
temp = temp -> next;
}
temp -> next = store;
}
void split_list(node* head, node** a, node** b)
{
struct node* fast = head -> next;
struct node* slow = head;
while (fast != NULL && fast -> next != NULL) {
slow = slow -> next;
fast = fast -> next -> next;
}
struct node* temp = slow -> next;
slow -> next = NULL;
*a = head;
*b = temp;
}
struct node* reverse(node* b)
{
struct node* curr = b;
struct node* next = NULL;
struct node* prev = NULL;
while (curr != NULL) {
next = curr -> next;
curr -> next = prev;
prev = curr;
curr = next;
}
return prev;
}
void merge(node* a, node* b, node** c)
{
struct node* temp = a;
*c = create_node(0);
struct node* curr = *c;
while (temp && b) {
curr -> next = create_node(temp -> data - b -> data);
b = b -> next;
temp = temp -> next;
curr = curr -> next;
//cout<<curr->data<<" ";
}
if (b != NULL) {
curr -> next = b;
curr = curr -> next;
}
curr -> next = reverse(a);
*c = (*c) -> next;
}
struct node* modifyTheList(struct node* head)
{
//add code here.
struct node* a;
struct node* b;
struct node* c;
split_list(head, &a, &b);
struct node* temp = reverse(b);
merge(temp, a, &c);
return c;
}
//Print the list
void print(node* head)
{
struct node* temp = head;
while (temp) {
cout << temp -> data << " ";
temp = temp -> next;
}
}
int main()
{
struct node* l = NULL;
push(&l, 1);
push(&l, 2);
push(&l, 3);
push(&l, 4);
push(&l, 5);
push(&l, 6);
cout << "Before the modify operation" << endl;
print(l);
l = modifyTheList(l);
cout << "nAfter the modify operation" << endl;
print(l);
return 0;
}

salida

Before the modify operation
1 2 3 4 5 6
After the modify operation
5 3 1 4 5 6


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *