Arranging Single Linked List in Alternate Odd and Even Nodes Order using JavaScript

Introduction

JavaScript is an object-oriented programming language generally used for internet enhancement. One thrilling operation of JavaScript is manipulating data structures, which include linked lists. In this educational, we will discover how to set up an unattached linked list in an alternate, atypical, and indeed bump-order operation of JavaScript. This algorithmic trouble requires solid information about connected lists and the capability to cut and manipulate bumps correctly.

Linked List Overview

A linked list is a statistical shape similar to bumps in which every knot points to the next one within the collection. A single connected table is characterized by its simplicity and dynamic nature, making it a really perfect solution for this problem.

Problem Statement

Given an unattached connected table, the task is to arrange its bumps in such a manner that all peculiar-listed bumps are observed by way of indeed-listed bumps. For illustration, an affiliated list with rudiments 1-> 2-> 3-> 4-> 5 needs to be rearranged as 1-> three-> 5-> 2-> four.

Approach

To solve this problem, we can follow a step-by-step approach with the use of JavaScript. First, we need to cut the connected list and insulate extraordinarily or indeed bumps into separate lists. Also, we will combine those lists within the favored order.

JavaScript provides an effective and suggestive platform for working with algorithmic issues, along with the manipulation of information structures like connected lists. In this educational, we explored a fashion to rearrange an unattached affiliated list in exchange for an atypical and indeed bumpy order. Understanding the basics of affiliated lists and using JavaScript's capabilities allowed us to apply a green system to this trouble. Feel untied to evolve and enlarge this law for different affiliated table manipulation scores or discover lesser advanced algorithms inside the realm of JavaScript programming.

Arranging Single Linked List in Alternate Odd and Even Nodes Order using JavaScript

Method 1 (Simple):

In this system, we produce two heaps: Odd and Indeed. We cut the list, and when we encounter an Indeed knot in an odd position, we push this knot's address onto the Indeed Stack. However, we push this knot's address onto the Odd Stack if we encounter an odd knot in an even position. After covering the list, we pop the bumps at the top of the two heaps and change their data. We keep repeating this step until the heaps are empty.

Step 1:

Produce two heaps of Odd and Indeed. These heaps will store the pointers to the bumps in the list.

Step 2:

Traverse the list from launch to end using the variable current. Repeat the following.

Step 3:

If the current knot is indeed present and it occurs in an odd position, push this knot's address to the mound.

Step 4:

If the current knot is odd and it occurs at an even position, push this knot's address to Mound Odd.

(END OF TRAVERSAL).

Step 5:

The size of both heaps will be the same. While both the heaps aren't empty, exchange the bumps at the top of the two. Heaps and pop both bumps from their separate heaps.

Step 6:

The list is now rearranged.

STOP

Implementation:

<script> 
// Javascript program to rearrange nodes as alternate odd even nodes in a Singly Linked List class node 
class Node 
{ constructor () 
{ 
this.data = 0; 
this.next = null; 
} 
} 
// A utility function to print 
// linked list 
function print list(node) 
{ 
while (node != null) 
{ 
document.write(node.data + " "); 
node = node. next; 
} 
document.write(); 
} 
//Function to create newNode 
// in a linked list 
function newNode(key) 
{ 
var temp = new Node(); 
temp.data = key; 
temp.next = null; 
return temp; 
} 
//Function to insert at the beginning 
function inserting(head, val) 
{ 
var temp = newNode(val); 
temp.next = head; 
head = temp; 
return head; 
} 
//Function to rearrange the 
// odd and even nodes 
function rearrangeOddEven(head) 
{ 
var odd = []; 
var even = []; 
var i = 1; 
while (head != null) 
{ 
if (head.data % 2 != 0 && 
i % 2 == 0) 
{ 
// Odd Value in Even Position 
// Add a pointer to the current node 
// in odd stack 
odd.push(head); 
} 
else if (head.data % 2 == 0 && 
i % 2 != 0) 
{ 
// Even Value in Odd Position 
// Add a pointer to the current node 
// in even stack 
even.push(head); 
} 
head = head.next; 
i++; 
} 
while (odd.length > 0 && 
even. length > 0) 
{ 
// Swap Data at the top of 
// two stacks 
var k = odd[odd.length - 1].data; 
odd[odd.length - 1].data = even[even.length - 1].data; 
even[even.length - 1].data = k; 
odd.pop(); 
even.pop(); 
}} 
// Driver code 
var head = newNode(8); 
head = insertBeg(head, 7); 
head = insertBeg(head, 6); 
head = insertBeg(head, 5); 
head = insertBeg(head, 3); 
head = insertBeg(head, 2); 
head = insertBeg(head, 1); 
document.write("Linked List:<br/>"); 
printList(head); 
rearrangeOddEven(head); 
document.write("<br/>Linked List after " + 
"Rearranging:<br/>"); 
printList(head); 
// This code is contributed by aashish1995 
</script>

Output

The output of the above code is:

Explanation:

The given JavaScript law defines a connected table and implements a point to arrange its bumps primarily based on their positions and values. The affiliated table is represented via a knot fineness, with each knot having a record subject and a posterior pointer to the coming knot. The print list points to the factors of the affiliated list.

The new node characteristic creates a brand new knot with a distinctive and crucial value. The inserting Function inserts a brand new knot on the morning of the affiliated table.

The main good judgment is inside the rearranged Odd Even characteristic, which iterates through the affiliated list, grading atypical values at indeed positions or indeed values at peculiar positions into separate heaps( ordinary and indeed). Also, it barters the values of corresponding bumps from the two heaps.

The motive force law creates an affiliated table and prints it ahead after rearranging the extraordinary and indeed placed rudiments. The rearrangement is done with the aid of switching values preceding a modified connected list.

Method 2 (Efficient)

Insulate peculiar and, indeed, valuable values within the table. After this, all odd values will arise inclusively, followed by all indeed values.
Split the list into lists that are atypical or indeed.
Combine the Indeed listing with the crazy list.
REARRANGE( HEAD)

1. Step 1:

Traverse the table using NODE TEMP.

If TEMP is odd

Add TEMP to the morning of the list.

END OF IF)

(END OF TRAVERSAL)

Step 2:

Set TEMP to alternate details of the list.

Step 3:

Set PREV_TEMP to the first element of the list.

Step 4:

Traverse the operation of knot TEMP is an excellent

the knot is yet to be encountered.

= TEMP, TEMP = TEMP- > NEXT

(END OF TRAVERSAL)

Step 5:

Set Indeed to TEMP. SetPREV_TEMP- > NEXT to NULL

Step 6:

I = HEAD, J = Indeed

Step 7:

Repetition while I! = NULL and J! = NULL

Store the posterior bumps of I and J in K and L.

K = I- > NEXT, L = J- > NEXT

I- > NEXT = J, J- > NEXT = K, PTR = J

I = K, and J = L.

(END OF THE CIRCLE)

Step 8:

If I == NULL

PTR > NEXT = J

END of IF)

Return Head.

Step 9:

End

Code:

// JavaScript program to rearrange nodes  
// as alternate odd even nodes in  
// a Singly Linked List  
// Structure node 
class Node  
{ 
    constructor()  
    { 
        this.data = 0; 
        this.next = null; 
    } 
} 
// A utility function to print 
// linked list 
function printList(node)  
{ 
    while (node != null)  
    { 
        document.write(node.data + " "); 
        node = node. next; 
    } 
    document.write("<br/>"); 
} 
//Function to create newNode 
// in a linked list 
function newNode(key)  
{ 
    var temp = new Node(); 
    temp.data = key; 
    temp.next = null; 
    return temp; 
} 
//Function to insert at the beginning 
function insertBeg(head, val)  
{ 
    var temp = newNode(val); 
    temp.next = head; 
    head = temp; 
    return head; 
} 
//Function to rearrange the 
// odd and even nodes 
function rearrange(head)  
{ 
    // Step 1: Segregate even and odd nodes 
    // Step 2: Split odd and even lists 
    // Step 3: Merge an even list into an odd list 
    var even; 
    var temp, prev_temp; 
    var i, j, k, l, ptr = null; 
    // Step 1: Segregate Odd and   
    // Even Nodes 
    temp = (head). next; 
    prev_temp = head; 
    while (temp != null)  
    { 
        // Backup next pointer of temp 
        var x = temp.next; 
        // If the temp is odd, move the node 
        // to the beginning of the list 
        if (temp. data % 2 != 0)  
        { 
            prev_temp.next = x; 
            temp.next = (head); 
            (head) = temp; 
        } 
        else 
        { 
            prev_temp = temp; 
        } 
        // Advance Temp Pointer 
        temp = x; 
    } 
    // Step 2 
    // Split the List into Odd and even 
    temp = (head).next; 
    prev_temp = (head); 
    while (temp != null &&  
           temp.data % 2 != 0)  
    { 
        prev_temp = temp; 
        temp = temp. next; 
    } 
    even = temp; 
    // End the odd List (Make last  
    // node null) 
    prev_temp.next = null; 
    // Step 3: 
    // Merge Even List into odd 
    i = head; 
    j = even; 
    while (j != null &&  
           i != null)  
    { 
        // While both lists are not 
        // exhausted Backup next 
        // pointers of i and j 
        k = i.next; 
        l = j.next; 
        i.next = j; 
        j.next = k; 
        // ptr points to the latest  
        // node added 
        ptr = j; 
        // Advance i and j pointers 
        i = k; 
        j = l; 
    } 
    if (i == null)  
    { 
        // Odd list exhausts before even, 
        // append remainder of even list 
        // to odd. 
        ptr.next = j; 
    } 
    // The case where even list exhausts  
    // before the odd list is automatically  
    // handled since we merge the event  
    // list into the odd list 
    return head; 
} 
// Driver Code 
var head = newNode(8); 
head = insertBeg(head, 7); 
head = insertBeg(head, 6); 
head = insertBeg(head, 3); 
head = insertBeg(head, 5); 
head = insertBeg(head, 1); 
head = insertBeg(head, 2); 
head = insertBeg(head, 10); 
document.write("Linked List:<br/>"); 
printList(head); 
document.write("Rearranged List<br/>"); 
head = rearrange(head); 
printList(head);

Output

The output of the above code is:

Explanation:

The handed JavaScript law demonstrates the rearrangement of an independently connected table by way of separating its bumps into atypical or indeed pots, unyoking them, and also incorporating the indeed bumps into the atypical bumps.

The Node class defines the shape of a connected table knot with a record subject and a coming pointer. The printList Function is software to show the rudiments of the linked list.

The new Node function creates a new knot with a given crucial price and inserts a new knot at the beginning of the linked list.

The rearrangement characteristic plays the rearrangement manner. It first segregates unusual or indeed bumps by transferring peculiar bumps to the morning. Also, it splits the table into ordinary and indeed factors. Eventually, it merges the indeed list into the strange list.

The motive force law creates a connected table, prints it, plays the rearrangement operation of the rearrange point, and prints the modified list. The rearrangement guarantees that peculiar and indeed relevant factors are alternatively arranged in the veritably last linked table.

Conclusion:

In the end, the perpetration of a JavaScript operation for arranging an unattached linked table in exchange for extraordinary and, indeed, bumps order showcases the language's versatility and effectiveness in working in algorithmically demanding situations. The handed fashion leverages the essential shape of connected lists to efficiently insulate atypical or indeed bumps before incorporating them into the asked order.

This problem highlights the significance of a strong matrix of data structures, specifically connected lists, and the capability to cut and control bumps efficiently. The modular and item-acquainted nature of JavaScript, as established in the law, contributes to the clarity of the answer.

As inventors, conforming and adding this law for analogous liabilities or exploring further superior algorithms will become doable, showcasing the power of JavaScript in addressing multitudinous programming challenges. Overall, this tutorial now not only addresses a named connected list rearrangement hassle but also serves as a realistic illustration of algorithmic hassle in the operation of JavaScript.

Next TopicFizzbuzz program in JavaScript

← prev next →