Replace even nodes of a doubly linked list with the elements of array
Given a doubly linked list and an array with only odd values. Both are of equal size N. The task is replace all node which have even value with the Array elements from left to right.
Examples:
Input : List = 6 9 8 7 4
Arr[] = {3, 5, 23, 17, 1}
Output : List = 3 9 5 7 23
Input : List = 9 14 7 12 8 13
Arr[] = {5, 1, 17, 21, 11, 7}
Output : List = 9 5 7 1 17 13
Approach: The idea is to traverse the nodes of the doubly linked list one by one and get the pointer of the nodes having even data then replace by the value of the array and increment the index of the array and move to the next node in the linked list.
Algorithm:
- Create the function push to add a node to the doubly linked list’s beginning.
- Establish a new node and assign memory to it.
- Incorporate data into the fresh node.
- Because the new node is being inserted first, set prior to null.
- Assign the old list’s next pointer to the list’s head in order to connect it to the new node.
- If the head is not null, change the head node’s previous pointer to the new node.
- Adjust the head so that it faces the new node.
- Give the new head node back.
- Establish a function Make each doubly linked list node odd by using the makeOddNode function.
- Move the cursor to the list’s top.
- Create a variable right after to hold the following node.
- should be declared as a variable to store the array’s index.
- Follow the linked list all the way to the end node.
- Determine whether the data for each node is even or odd.
- If the node data is even, swap it out for array As i-th element and increase i.
- The pointer is set to the following node.
- Retrieve the modified doubly linked list’s head.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node *prev, *next;
};
void push(Node** head_ref, int new_data)
{
Node* new_node = (Node*) malloc ( sizeof ( struct Node));
new_node->data = new_data;
new_node->prev = NULL;
new_node->next = (*head_ref);
if ((*head_ref) != NULL)
(*head_ref)->prev = new_node;
(*head_ref) = new_node;
}
void makeOddNode(Node** head_ref, int A[], int n)
{
Node* ptr = *head_ref;
Node* next;
int i = 0;
while (ptr != NULL) {
next = ptr->next;
if (ptr->data % 2 == 0) {
ptr->data = A[i];
i++;
}
ptr = next;
}
}
void printList(Node* head)
{
while (head != NULL) {
cout << head->data << " " ;
head = head->next;
}
}
int main()
{
Node* head = NULL;
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
class GFG
{
static class Node
{
int data;
Node prev, next;
};
static Node push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.prev = null ;
new_node.next = (head_ref);
if ((head_ref) != null )
(head_ref).prev = new_node;
(head_ref) = new_node;
return head_ref;
}
static Node makeOddNode(Node head_ref, int A[], int n)
{
Node ptr = head_ref;
Node next;
int i = 0 ;
while (ptr != null )
{
next = ptr.next;
if (ptr.data % 2 == 0 )
{
ptr.data = A[i];
i++;
}
ptr = next;
}
return head_ref;
}
static void printList(Node head)
{
while (head != null )
{
System.out.print( head.data + " " );
head = head.next;
}
}
public static void main(String args[])
{
Node head = null ;
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);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .prev = None
self . next = None
def push(head_ref, new_data):
new_node = Node(new_data)
new_node. next = head_ref
if head_ref ! = None :
head_ref.prev = new_node
head_ref = new_node
return head_ref
def makeOddNode(head_ref, A, n):
ptr = head_ref
i = 0
while ptr ! = None :
next = ptr. next
if ptr.data % 2 = = 0 :
ptr.data = A[i]
i + = 1
ptr = next
def printList(head):
while head ! = None :
print (head.data, end = " " )
head = head. next
if __name__ = = "__main__" :
head = None
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)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node prev, next;
};
static Node push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.prev = null ;
new_node.next = (head_ref);
if ((head_ref) != null )
(head_ref).prev = new_node;
(head_ref) = new_node;
return head_ref;
}
static Node makeOddNode(Node head_ref, int []A, int n)
{
Node ptr = head_ref;
Node next;
int i = 0;
while (ptr != null )
{
next = ptr.next;
if (ptr.data % 2 == 0)
{
ptr.data = A[i];
i++;
}
ptr = next;
}
return head_ref;
}
static void printList(Node head)
{
while (head != null )
{
Console.Write( head.data + " " );
head = head.next;
}
}
public static void Main(String []args)
{
Node head = null ;
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);
}
}
|
Javascript
<script>
class Node {
constructor(val) {
this .data = val;
this .prev = null ;
this .next = null ;
}
}
function push(head_ref , new_data) {
var new_node = new Node();
new_node.data = new_data;
new_node.prev = null ;
new_node.next = (head_ref);
if ((head_ref) != null )
(head_ref).prev = new_node;
(head_ref) = new_node;
return head_ref;
}
function makeOddNode(head_ref , A , n) {
var ptr = head_ref;
var next;
var i = 0;
while (ptr != null ) {
next = ptr.next;
if (ptr.data % 2 == 0) {
ptr.data = A[i];
i++;
}
ptr = next;
}
return head_ref;
}
function printList(head) {
while (head != null ) {
document.write(head.data + " " );
head = head.next;
}
}
var head = null ;
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);
</script>
|
Output:
Original List: 6 9 8 7 4
New odd List: 3 9 5 7 23
Time Complexity: O(N), where N is the total number of nodes.
Auxiliary Space: O(1) because it is using constant space
Last Updated :
17 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...