Dada una lista doblemente enlazada y una array con solo valores impares. Ambos son del mismo tamaño N. La tarea es reemplazar todos los Nodes que tienen un valor par con los elementos del Array de izquierda a derecha.
Ejemplos:
Entrada: Lista = 6 9 8 7 4
Arr[] = {3, 5, 23, 17, 1}
Salida: Lista = 3 9 5 7 23
Entrada: Lista = 9 14 7 12 8 13
Arr[] = {5, 1, 17, 21, 11, 7}
Salida: Lista = 9 5 7 1 17 13
Enfoque: la idea es atravesar los Nodes de la lista doblemente enlazada uno por uno y obtener el puntero de los Nodes que tienen datos pares, luego reemplazarlos por el valor de la array e incrementar el índice de la array y pasar al siguiente Node en el lista enlazada.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ implementation to create
// odd doubly linked list
#include <bits/stdc++.h>
using namespace std;
// Node of the doubly linked list
struct Node {
int data;
Node *prev, *next;
};
// function to insert a node at the beginning
// of the Doubly Linked List
void push(Node** head_ref, int new_data)
{
// allocate node
Node* new_node = (Node*)malloc(sizeof(struct Node));
// put in the data
new_node->data = new_data;
// since we are adding at the beginning,
// prev is always NULL
new_node->prev = NULL;
// link the old list off the new node
new_node->next = (*head_ref);
// change prev of head node to new node
if ((*head_ref) != NULL)
(*head_ref)->prev = new_node;
// move the head to point to the new node
(*head_ref) = new_node;
}
// function to make all node is odd
void makeOddNode(Node** head_ref, int A[], int n)
{
Node* ptr = *head_ref;
Node* next;
int i = 0;
// traverse list till last node
while (ptr != NULL) {
next = ptr->next;
// check if node is even then
// replace it and increment in i
if (ptr->data % 2 == 0) {
ptr->data = A[i];
i++;
}
ptr = next;
}
// return sum of nodes which is divided by K
}
// function to print nodes in a
// given doubly linked list
void printList(Node* head)
{
while (head != NULL) {
cout << head->data << " ";
head = head->next;
}
}
// Driver program to test above
int main()
{
// start with the empty list
Node* head = NULL;
// create the doubly linked list
// 6 <=> 9 <=> 8 <=> 7 <=> 4
int Arr[] = { 3, 5, 23, 17, 1 };
push(&head, 4);
push(&head, 7);
push(&head, 8);
push(&head, 9);
push(&head, 6);
int n = sizeof(Arr) / sizeof(Arr[0]);
cout << "Original List: ";
printList(head);
cout << endl;
makeOddNode(&head, Arr, n);
cout << "New odd List: ";
printList(head);
}
Java
// Java implementation to create
// odd doubly linked list
class GFG
{
// Node of the doubly linked list
static class Node
{
int data;
Node prev, next;
};
// function to insert a node at the beginning
// of the Doubly Linked List
static Node push(Node head_ref, int new_data)
{
// allocate node
Node new_node = new Node();
// put in the data
new_node.data = new_data;
// since we are adding at the beginning,
// prev is always null
new_node.prev = null;
// link the old list off the new node
new_node.next = (head_ref);
// change prev of head node to new node
if ((head_ref) != null)
(head_ref).prev = new_node;
// move the head to point to the new node
(head_ref) = new_node;
return head_ref;
}
// function to make all node is odd
static Node makeOddNode(Node head_ref, int A[], int n)
{
Node ptr = head_ref;
Node next;
int i = 0;
// traverse list till last node
while (ptr != null)
{
next = ptr.next;
// check if node is even then
// replace it and increment in i
if (ptr.data % 2 == 0)
{
ptr.data = A[i];
i++;
}
ptr = next;
}
// return sum of nodes which is divided by K
return head_ref;
}
// function to print nodes in a
// given doubly linked list
static void printList(Node head)
{
while (head != null)
{
System.out.print( head.data + " ");
head = head.next;
}
}
// Driver code
public static void main(String args[])
{
// start with the empty list
Node head = null;
// create the doubly linked list
// 6 <=> 9 <=> 8 <=> 7 <=> 4
int Arr[] = { 3, 5, 23, 17, 1 };
head = push(head, 4);
head = push(head, 7);
head = push(head, 8);
head = push(head, 9);
head = push(head, 6);
int n = Arr.length;
System.out.print( "Original List: ");
printList(head);
System.out.println();
head = makeOddNode(head, Arr, n);
System.out.print("New odd List: ");
printList(head);
}
}
// This code is contributed by Arnab Kundu
Python3
# Python3 implementation to
# create odd doubly linked list
# Node of the doubly linked list
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None
# Function to insert a node at the
# beginning of the Doubly Linked List
def push(head_ref, new_data):
# allocate node
new_node = Node(new_data)
# link the old list off the new node
new_node.next = head_ref
# change prev of head node to new node
if head_ref != None:
head_ref.prev = new_node
# move the head to point to the new node
head_ref = new_node
return head_ref
# Function to make all node is odd
def makeOddNode(head_ref, A, n):
ptr = head_ref
i = 0
# traverse list till last node
while ptr != None:
next = ptr.next
# check if node is even then
# replace it and increment in i
if ptr.data % 2 == 0:
ptr.data = A[i]
i += 1
ptr = next
# return sum of nodes which is divided by K
# Function to print nodes in a
# given doubly linked list
def printList(head):
while head != None:
print(head.data, end = " ")
head = head.next
# Driver Code
if __name__ == "__main__":
# start with the empty list
head = None
# create the doubly linked list
# 6 <=> 9 <=> 8 <=> 7 <=> 4
Arr = [3, 5, 23, 17, 1]
head = push(head, 4)
head = push(head, 7)
head = push(head, 8)
head = push(head, 9)
head = push(head, 6)
n = len(Arr)
print("Original List:", end = " ")
printList(head)
print()
makeOddNode(head, Arr, n)
print("New odd List:", end = " ")
printList(head)
# This code is contributed by Rituraj Jain
C#
// C# implementation to create
// odd doubly linked list
using System;
class GFG
{
// Node of the doubly linked list
public class Node
{
public int data;
public Node prev, next;
};
// function to insert a node at the beginning
// of the Doubly Linked List
static Node push(Node head_ref, int new_data)
{
// allocate node
Node new_node = new Node();
// put in the data
new_node.data = new_data;
// since we are adding at the beginning,
// prev is always null
new_node.prev = null;
// link the old list off the new node
new_node.next = (head_ref);
// change prev of head node to new node
if ((head_ref) != null)
(head_ref).prev = new_node;
// move the head to point to the new node
(head_ref) = new_node;
return head_ref;
}
// function to make all node is odd
static Node makeOddNode(Node head_ref, int []A, int n)
{
Node ptr = head_ref;
Node next;
int i = 0;
// traverse list till last node
while (ptr != null)
{
next = ptr.next;
// check if node is even then
// replace it and increment in i
if (ptr.data % 2 == 0)
{
ptr.data = A[i];
i++;
}
ptr = next;
}
// return sum of nodes which is divided by K
return head_ref;
}
// function to print nodes in a
// given doubly linked list
static void printList(Node head)
{
while (head != null)
{
Console.Write( head.data + " ");
head = head.next;
}
}
// Driver code
public static void Main(String []args)
{
// start with the empty list
Node head = null;
// create the doubly linked list
// 6 <=> 9 <=> 8 <=> 7 <=> 4
int []Arr = { 3, 5, 23, 17, 1 };
head = push(head, 4);
head = push(head, 7);
head = push(head, 8);
head = push(head, 9);
head = push(head, 6);
int n = Arr.Length;
Console.WriteLine( "Original List: ");
printList(head);
Console.WriteLine();
head = makeOddNode(head, Arr, n);
Console.WriteLine("New odd List: ");
printList(head);
}
}
// This code contributed by Rajput-Ji
Javascript
<script>
// JavaScript implementation to create
// odd doubly linked list
// Node of the doubly linked list
class Node {
constructor(val) {
this.data = val;
this.prev = null;
this.next = null;
}
}
// function to insert a node at the beginning
// of the Doubly Linked List
function push(head_ref , new_data) {
// allocate node
var new_node = new Node();
// put in the data
new_node.data = new_data;
// since we are adding at the beginning,
// prev is always null
new_node.prev = null;
// link the old list off the new node
new_node.next = (head_ref);
// change prev of head node to new node
if ((head_ref) != null)
(head_ref).prev = new_node;
// move the head to point to the new node
(head_ref) = new_node;
return head_ref;
}
// function to make all node is odd
function makeOddNode(head_ref , A , n) {
var ptr = head_ref;
var next;
var i = 0;
// traverse list till last node
while (ptr != null) {
next = ptr.next;
// check if node is even then
// replace it and increment in i
if (ptr.data % 2 == 0) {
ptr.data = A[i];
i++;
}
ptr = next;
}
// return sum of nodes which is divided by K
return head_ref;
}
// function to print nodes in a
// given doubly linked list
function printList(head) {
while (head != null) {
document.write(head.data + " ");
head = head.next;
}
}
// Driver code
// start with the empty list
var head = null;
// create the doubly linked list
// 6 <=> 9 <=> 8 <=> 7 <=> 4
var Arr = [ 3, 5, 23, 17, 1 ];
head = push(head, 4);
head = push(head, 7);
head = push(head, 8);
head = push(head, 9);
head = push(head, 6);
var n = Arr.length;
document.write("Original List: ");
printList(head);
document.write("<br/>");
head = makeOddNode(head, Arr, n);
document.write("New odd List: ");
printList(head);
// This code contributed by umadevi9616
</script>
Producción:
Original List: 6 9 8 7 4 New odd List: 3 9 5 7 23
Complejidad temporal: O(N), donde N es el número total de Nodes.