# Rearrange a Linked List in Zig-Zag fashion

• Difficulty Level : Medium
• Last Updated : 05 Jan, 2023

Given a linked list, rearrange it such that the converted list should be of the form a < b > c < d > e < f â€¦ where a, b, câ€¦ are consecutive data nodes of the linked list.

Examples:

```Input:  1->2->3->4
Output: 1->3->2->4
Explanation : 1 and 3 should come first before 2 and 4 in zig-zag fashion, So resultant linked-list will be 1->3->2->4.

Input:  11->15->20->5->10
Output: 11->20->5->15->10 ```

## We strongly recommend that you click here and practice it, before moving on to the solution.

A simple approach to do this is to sort the linked list using merge sort and then swap alternate, but that requires O(n Log n) time complexity. Here n is a number of elements in the linked list.

An efficient approach that requires O(n) time is, using a single scan similar to bubble sort and then maintain a flag for representing which order () currently we are. If the current two elements are not in that order then swap those elements otherwise not. Please refer to this for a detailed explanation of the swapping order.

Implementation:

## C++

 `// C++ program to arrange linked list in zigzag fashion` `#include ` `using` `namespace` `std;`   `/* Link list Node */` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `// This function distributes the Node in zigzag fashion` `void` `zigZagList(Node* head)` `{` `    ``// If flag is true, then next node should be greater in` `    ``// the desired output.` `    ``bool` `flag = ``true``;`   `    ``// Traverse linked list starting from head.` `    ``Node* current = head;` `    ``while` `(current->next != NULL) {` `        ``if` `(flag) ``/* "<" relation expected */` `        ``{` `            ``// If we have a situation like A > B > C where` `            ``// A, B and C are consecutive Nodes in list we` `            ``// get A > B < C by swapping B and C` `            ``if` `(current->data > current->next->data)` `                ``swap(current->data, current->next->data);` `        ``}` `        ``else` `/* ">" relation expected */` `        ``{` `            ``// If we have a situation like A < B < C where` `            ``// A, B and C  are consecutive Nodes in list we` `            ``// get A < C > B by swapping B and C` `            ``if` `(current->data < current->next->data)` `                ``swap(current->data, current->next->data);` `        ``}`   `        ``current = current->next;` `        ``flag = !flag; ``/* flip flag for reverse checking */` `    ``}` `}`   `/* UTILITY FUNCTIONS */` `/* Function to push a Node */` `void` `push(Node** head_ref, ``int` `new_data)` `{` `    ``/* allocate Node */` `    ``struct` `Node* new_Node = ``new` `Node;`   `    ``/* put in the data  */` `    ``new_Node->data = new_data;`   `    ``/* link the old list of the new Node */` `    ``new_Node->next = (*head_ref);`   `    ``/* move the head to point to the new Node */` `    ``(*head_ref) = new_Node;` `}`   `/* Function to print linked list */` `void` `printList(``struct` `Node* Node)` `{` `    ``while` `(Node != NULL) {` `        ``printf``(``"%d->"``, Node->data);` `        ``Node = Node->next;` `    ``}` `    ``printf``(``"NULL"``);` `}`   `/* Driver program to test above function*/` `int` `main(``void``)` `{` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL;`   `    ``// create a list 4 -> 3 -> 7 -> 8 -> 6 -> 2 -> 1` `    ``// answer should be -> 3  7  4  8  2  6  1` `    ``push(&head, 1);` `    ``push(&head, 2);` `    ``push(&head, 6);` `    ``push(&head, 8);` `    ``push(&head, 7);` `    ``push(&head, 3);` `    ``push(&head, 4);`   `    ``printf``(``"Given linked list \n"``);` `    ``printList(head);`   `    ``zigZagList(head);`   `    ``printf``(``"\nZig Zag Linked list \n"``);` `    ``printList(head);`   `    ``return` `(0);` `}`   `// This code is contributed by Sania Kumari Gupta (kriSania804)`

## C

 `// C program to arrange linked list in zigzag fashion` `#include ` `#include ` `#include `   `/* Link list Node */` `typedef` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `} Node;`   `// This function swaps values pointed by xp and yp` `void` `swap(``int``* xp, ``int``* yp)` `{` `    ``int` `temp = *xp;` `    ``*xp = *yp;` `    ``*yp = temp;` `}`   `// This function distributes the Node in zigzag fashion` `void` `zigZagList(Node* head)` `{` `    ``// If flag is true, then next node should be greater in` `    ``// the desired output.` `    ``bool` `flag = ``true``;`   `    ``// Traverse linked list starting from head.` `    ``Node* current = head;` `    ``while` `(current->next != NULL) {` `        ``if` `(flag) ``/* "<" relation expected */` `        ``{` `            ``// If we have a situation like A > B > C where` `            ``// A, B and C are consecutive Nodes in list we` `            ``// get A > B < C by swapping B and C` `            ``if` `(current->data > current->next->data)` `                ``swap(¤t->data, ¤t->next->data);` `        ``}` `        ``else` `/* ">" relation expected */` `        ``{` `            ``// If we have a situation like A < B < C where` `            ``// A, B and C  are consecutive Nodes in list we` `            ``// get A < C > B by swapping B and C` `            ``if` `(current->data < current->next->data)` `                ``swap(¤t->data, ¤t->next->data);` `        ``}`   `        ``current = current->next;` `        ``flag = !flag; ``/* flip flag for reverse checking */` `    ``}` `}`   `/* UTILITY FUNCTIONS */` `/* Function to push a Node */` `void` `push(Node** head_ref, ``int` `new_data)` `{` `    ``/* allocate Node */` `    ``struct` `Node* new_Node = (Node*)``malloc``(``sizeof``(Node));`   `    ``/* put in the data  */` `    ``new_Node->data = new_data;`   `    ``/* link the old list of the new Node */` `    ``new_Node->next = (*head_ref);`   `    ``/* move the head to point to the new Node */` `    ``(*head_ref) = new_Node;` `}`   `/* Function to print linked list */` `void` `printList(``struct` `Node* Node)` `{` `    ``while` `(Node != NULL) {` `        ``printf``(``"%d->"``, Node->data);` `        ``Node = Node->next;` `    ``}` `    ``printf``(``"NULL"``);` `}`   `/* Driver program to test above function*/` `int` `main(``void``)` `{` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL;`   `    ``// create a list 4 -> 3 -> 7 -> 8 -> 6 -> 2 -> 1` `    ``// answer should be -> 3  7  4  8  2  6  1` `    ``push(&head, 1);` `    ``push(&head, 2);` `    ``push(&head, 6);` `    ``push(&head, 8);` `    ``push(&head, 7);` `    ``push(&head, 3);` `    ``push(&head, 4);`   `    ``printf``(``"Given linked list \n"``);` `    ``printList(head);`   `    ``zigZagList(head);`   `    ``printf``(``"\nZig Zag Linked list \n"``);` `    ``printList(head);`   `    ``return` `(0);` `}`   `// This code is contributed by Sania Kumari Gupta (kriSania804)`

## Java

 `// Java program to arrange` `// linked list in zigzag fashion` `class` `GfG {`   `    ``/* Link list Node */` `    ``static` `class` `Node {` `        ``int` `data;` `        ``Node next;` `    ``}` `    ``static` `Node head = ``null``;` `    ``static` `int` `temp = ``0``;`   `    ``// This function distributes` `    ``// the Node in zigzag fashion` `    ``static` `void` `zigZagList(Node head)` `    ``{` `        ``// If flag is true, then` `        ``// next node should be greater` `        ``// in the desired output.` `        ``boolean` `flag = ``true``;`   `        ``// Traverse linked list starting from head.` `        ``Node current = head;` `        ``while` `(current != ``null` `&& current.next != ``null``) {` `            ``if` `(flag == ``true``) ``/* "<" relation expected */` `            ``{` `                ``/* If we have a situation like A > B > C ` `            ``where A, B and C are consecutive Nodes ` `            ``in list we get A > B < C by swapping B ` `            ``and C */` `                ``if` `(current.data > current.next.data) {` `                    ``temp = current.data;` `                    ``current.data = current.next.data;` `                    ``current.next.data = temp;` `                ``}` `            ``}` `            ``else` `/* ">" relation expected */` `            ``{` `                ``/* If we have a situation like A < B < C where ` `            ``A, B and C are consecutive Nodes in list we ` `            ``get A < C > B by swapping B and C */` `                ``if` `(current.data < current.next.data) {` `                    ``temp = current.data;` `                    ``current.data = current.next.data;` `                    ``current.next.data = temp;` `                ``}` `            ``}`   `            ``current = current.next;`   `            ``/* flip flag for reverse checking */` `            ``flag = !(flag);` `        ``}` `    ``}`   `    ``/* UTILITY FUNCTIONS */` `    ``/* Function to push a Node */` `    ``static` `void` `push(``int` `new_data)` `    ``{` `        ``/* allocate Node */` `        ``Node new_Node = ``new` `Node();`   `        ``/* put in the data */` `        ``new_Node.data = new_data;`   `        ``/* link the old list of the new Node */` `        ``new_Node.next = (head);`   `        ``/* move the head to point to the new Node */` `        ``(head) = new_Node;` `    ``}`   `    ``/* Function to print linked list */` `    ``static` `void` `printList(Node Node)` `    ``{` `        ``while` `(Node != ``null``) {` `            ``System.out.print(Node.data + ``"->"``);` `            ``Node = Node.next;` `        ``}` `        ``System.out.println(``"NULL"``);` `    ``}`   `    ``/* Driver code*/` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``/* Start with the empty list */` `        ``// Node head = null;`   `        ``// create a list 4 -> 3 -> 7 -> 8 -> 6 -> 2 -> 1` `        ``// answer should be -> 3 7 4 8 2 6 1` `        ``push(``1``);` `        ``push(``2``);` `        ``push(``6``);` `        ``push(``8``);` `        ``push(``7``);` `        ``push(``3``);` `        ``push(``4``);`   `        ``System.out.println(``"Given linked list "``);` `        ``printList(head);`   `        ``zigZagList(head);`   `        ``System.out.println(``"Zig Zag Linked list "``);` `        ``printList(head);` `    ``}` `}`   `// This code is contributed by` `// Prerna Saini.`

## Python

 `# Python code to rearrange linked list in zig zag fashion`   `# Node class ` `class` `Node: `   `    ``# Constructor to initialize the node object ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None`     `# This function distributes the Node in zigzag fashion` `def` `zigZagList(head):`   `    ``# If flag is true, then next node should be greater` `    ``# in the desired output.` `    ``flag ``=` `True`   `    ``# Traverse linked list starting from head.` `    ``current ``=` `head` `    ``while` `(current.``next` `!``=` `None``):` `    `  `        ``if` `(flag): ``# "<" relation expected` `        `  `            ``# If we have a situation like A > B > C` `            ``# where A, B and C are consecutive Nodes` `            ``# in list we get A > B < C by swapping B` `            ``# and C ` `            ``if` `(current.data > current.``next``.data):` `                ``t ``=` `current.data` `                ``current.data ``=` `current.``next``.data` `                ``current.``next``.data ``=` `t` `            `  `        `  `        ``else` `:``# ">" relation expected` `        `  `            ``# If we have a situation like A < B < C where` `            ``# A, B and C are consecutive Nodes in list we` `            ``# get A < C > B by swapping B and C ` `            ``if` `(current.data < current.``next``.data):` `                ``t ``=` `current.data` `                ``current.data ``=` `current.``next``.data` `                ``current.``next``.data ``=` `t` `            `  `        ``current ``=` `current.``next` `        ``if``(flag):` `            ``flag ``=` `False` `# flip flag for reverse checking ` `        ``else``:` `            ``flag ``=` `True` `    ``return` `head`   `# function to insert a Node in ` `# the linked list at the beginning.` `def` `push(head, k):`   `    ``tem ``=` `Node(``0``)` `    ``tem.data ``=` `k` `    ``tem.``next` `=` `head` `    ``head ``=` `tem` `    ``return` `head`   `# function to display Node of linked list.` `def` `display( head):`   `    ``curr ``=` `head` `    ``while` `(curr !``=` `None``): ` `        ``print``( curr.data, ``"->"``, end ``=``" "``)` `        ``curr ``=` `curr.``next` `    `  `    ``print``(``"None"``)`   `# Driver code`   `head ``=` `None`   `# create a list 4 -> 3 -> 7 -> 8 -> 6 -> 2 -> 1` `# answer should be -> 3 7 4 8 2 6 1` `head ``=` `push(head, ``1``)` `head ``=` `push(head, ``2``)` `head ``=` `push(head, ``6``)` `head ``=` `push(head, ``8``)` `head ``=` `push(head, ``7``)` `head ``=` `push(head, ``3``)` `head ``=` `push(head, ``4``)`   `print``(``"Given linked list \n"``)` `display(head)`   `head ``=` `zigZagList(head)`   `print``(``"\nZig Zag Linked list \n"``)` `display(head)`   `# This code is contributed by Arnab Kundu`

## C#

 `// C# program to arrange` `// linked list in zigzag fashion` `using` `System;`   `class` `GfG {`   `    ``/* Link list Node */` `    ``class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `    ``}` `    ``static` `Node head = ``null``;` `    ``static` `int` `temp = 0;`   `    ``// This function distributes` `    ``// the Node in zigzag fashion` `    ``static` `void` `zigZagList(Node head)` `    ``{` `        ``// If flag is true, then` `        ``// next node should be greater` `        ``// in the desired output.` `        ``bool` `flag = ``true``;`   `        ``// Traverse linked list starting from head.` `        ``Node current = head;` `        ``while` `(current != ``null` `&& current.next != ``null``) {` `            ``if` `(flag == ``true``) ``/* "<" relation expected */` `            ``{` `                ``/* If we have a situation like A > B > C ` `                ``where A, B and C are consecutive Nodes ` `                ``in list we get A > B < C by swapping B ` `                ``and C */` `                ``if` `(current != ``null` `&& current.next != ``null` `&& current.data > current.next.data) {` `                    ``temp = current.data;` `                    ``current.data = current.next.data;` `                    ``current.next.data = temp;` `                ``}` `            ``}` `            ``else` `/* ">" relation expected */` `            ``{` `                ``/* If we have a situation like A < B < C where ` `                ``A, B and C are consecutive Nodes in list we ` `                ``get A < C > B by swapping B and C */` `                ``if` `(current != ``null` `&& current.next != ``null` `&& current.data < current.next.data) {` `                    ``temp = current.data;` `                    ``current.data = current.next.data;` `                    ``current.next.data = temp;` `                ``}` `            ``}`   `            ``current = current.next;`   `            ``/* flip flag for reverse checking */` `            ``flag = !(flag);` `        ``}` `    ``}`   `    ``/* UTILITY FUNCTIONS */` `    ``/* Function to push a Node */` `    ``static` `void` `push(``int` `new_data)` `    ``{` `        ``/* allocate Node */` `        ``Node new_Node = ``new` `Node();`   `        ``/* put in the data */` `        ``new_Node.data = new_data;`   `        ``/* link the old list of the new Node */` `        ``new_Node.next = (head);`   `        ``/* move the head to point to the new Node */` `        ``(head) = new_Node;` `    ``}`   `    ``/* Function to print linked list */` `    ``static` `void` `printList(Node Node)` `    ``{` `        ``while` `(Node != ``null``) {` `            ``Console.Write(Node.data + ``"->"``);` `            ``Node = Node.next;` `        ``}` `        ``Console.WriteLine(``"NULL"``);` `    ``}`   `    ``/* Driver code*/` `    ``public` `static` `void` `Main()` `    ``{` `        ``/* Start with the empty list */` `        ``// Node head = null;`   `        ``// create a list 4 -> 3 -> 7 -> 8 -> 6 -> 2 -> 1` `        ``// answer should be -> 3 7 4 8 2 6 1` `        ``push(1);` `        ``push(2);` `        ``push(6);` `        ``push(8);` `        ``push(7);` `        ``push(3);` `        ``push(4);`   `        ``Console.WriteLine(``"Given linked list "``);` `        ``printList(head);`   `        ``zigZagList(head);`   `        ``Console.WriteLine(``"Zig Zag Linked list "``);` `        ``printList(head);` `    ``}` `}` `/* This code is contributed PrinciRaj1992 */`

## Javascript

 ``

Output

```Given linked list
4->3->7->8->6->2->1->NULL
3->7->4->8->2->6->1->NULL```

Another Approach:
In the above code, the push function pushes the node at the front of the linked list, the code can be easily modified for pushing the node at the end of the list. Another thing to note is, swapping of data between two nodes is done by swap by value not swap by links for simplicity, for the swap by links technique please see this.

This can be also be done recursively. The idea remains the same, let us suppose the value of the flag determines the condition we need to check for comparing the current element. So, if the flag is 0 (or false) the current element should be smaller than the next and if the flag is 1 ( or true ) then the current element should be greater than the next. If not, swap the values of nodes.

Implementation:

## C++

 `// C++ program to arrange linked list` `// in zigzag fashion` `#include ` `using` `namespace` `std;`   `// a linked list node` `struct` `node {` `    ``int` `data;` `    ``node* next;` `};`   `/* Function to push a Node */` `void` `push(node** head_ref, ``int` `new_data)` `{` `    ``node* new_Node = (node*)``malloc``(``sizeof``(node));` `    ``new_Node->data = new_data;` `    ``new_Node->next = (*head_ref);` `    ``(*head_ref) = new_Node;` `}`   `// Rearrange the linked list in zig zag way` `node* zigzag(node* head, ``bool` `flag)` `{` `    ``if` `(!head || !head->next)` `        ``return` `head;` `    ``if` `(flag == 1) {` `        ``if` `(head->data > head->next->data)` `            ``swap(head->data, head->next->data);` `        ``return` `zigzag(head->next, !flag);` `    ``}` `    ``else` `{` `        ``if` `(head->data < head->next->data)` `            ``swap(head->data, head->next->data);` `        ``return` `zigzag(head->next, !flag);` `    ``}` `}`   `// fun to print list` `void` `printList(node* head)` `{` `    ``while` `(head) {` `        ``cout << head->data << ``"-> "``;` `        ``head = head->next;` `    ``}` `    ``cout << ``"NULL"``;` `}`   `// main fun` `int` `main()` `{`   `    ``node* head = NULL;` `    ``push(&head, 10);` `    ``push(&head, 5);` `    ``push(&head, 20);` `    ``push(&head, 15);` `    ``push(&head, 11);`   `    ``printList(head);` `    ``cout << endl;`   `    ``zigzag(head, 1);`   `    ``cout << ``"LL in zig zag fashion : "` `<< endl;` `    ``printList(head);` `    ``return` `0;` `}`   `// This code is contributed by Upendra`

## C

 `// C program to arrange linked list in zigzag fashion` `#include ` `#include ` `#include `   `// a linked list node` `typedef` `struct` `node {` `    ``int` `data;` `    ``struct` `node* next;` `} node;`   `void` `push(node** head_ref, ``int` `new_data)` `{` `    ``node* new_Node = (node*)``malloc``(``sizeof``(node));` `    ``new_Node->data = new_data;` `    ``new_Node->next = (*head_ref);` `    ``(*head_ref) = new_Node;` `}`   `// function to swap the elements` `void` `swap(``int``* xp, ``int``* yp)` `{` `    ``int` `temp = *xp;` `    ``*xp = *yp;` `    ``*yp = temp;` `}`   `// Rearrange the linked list in zig zag way` `node* zigzag(node* head, ``bool` `flag)` `{` `    ``if` `(!head || !head->next)` `        ``return` `head;` `    ``if` `(flag == 1) {` `        ``if` `(head->data > head->next->data)` `            ``swap(&head->data, &head->next->data);` `        ``return` `zigzag(head->next, !flag);` `    ``}` `    ``else` `{` `        ``if` `(head->data < head->next->data)` `            ``swap(&head->data, &head->next->data);` `        ``return` `zigzag(head->next, !flag);` `    ``}` `}`   `// fun to print list` `void` `printList(node* head)` `{` `    ``while` `(head) {` `        ``printf``(``"%d-> "``, head->data);` `        ``head = head->next;` `    ``}` `    ``printf``(``"NULL"``);` `}`   `// main fun` `int` `main()` `{`   `    ``node* head = NULL;` `    ``push(&head, 10);` `    ``push(&head, 5);` `    ``push(&head, 20);` `    ``push(&head, 15);` `    ``push(&head, 11);`   `    ``printList(head);` `    ``printf``(``"\n"``);`   `    ``zigzag(head, 1);`   `    ``printf``(``"LL in zig zag fashion : \n"``);` `    ``printList(head);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program for the above approach` `import` `java.io.*;`   `// Node class` `class` `Node {` `    ``int` `data;` `    ``Node next;` `    ``Node(``int` `data) { ``this``.data = data; }` `}`   `public` `class` `GFG {`   `    ``private` `Node head;`   `    ``// Print Linked List` `    ``public` `void` `printLL()` `    ``{` `        ``Node t = head;` `        ``while` `(t != ``null``) {` `            ``System.out.print(t.data + ``" ->"``);` `            ``t = t.next;` `        ``}` `        ``System.out.println();` `    ``}`   `    ``// Swap both nodes` `    ``public` `void` `swap(Node a, Node b)` `    ``{` `        ``if` `(a == ``null` `|| b == ``null``)` `            ``return``;` `        ``int` `temp = a.data;` `        ``a.data = b.data;` `        ``b.data = temp;` `    ``}`   `    ``// Rearrange the linked list` `    ``// in zig zag way` `    ``public` `Node zigZag(Node node, ``int` `flag)` `    ``{` `        ``if` `(node == ``null` `|| node.next == ``null``) {` `            ``return` `node;` `        ``}` `        ``if` `(flag == ``0``) {` `            ``if` `(node.data > node.next.data) {` `                ``swap(node, node.next);` `            ``}` `            ``return` `zigZag(node.next, ``1``);` `        ``}` `        ``else` `{` `            ``if` `(node.data < node.next.data) {` `                ``swap(node, node.next);` `            ``}` `            ``return` `zigZag(node.next, ``0``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``GFG lobj = ``new` `GFG();` `        ``lobj.head = ``new` `Node(``11``);` `        ``lobj.head.next = ``new` `Node(``15``);` `        ``lobj.head.next.next = ``new` `Node(``20``);` `        ``lobj.head.next.next.next = ``new` `Node(``5``);` `        ``lobj.head.next.next.next.next = ``new` `Node(``10``);` `        ``lobj.printLL();`   `        ``// 0 means the current element` `        ``// should be smaller than the next` `        ``int` `flag = ``0``;` `        ``lobj.zigZag(lobj.head, flag);` `        ``System.out.println(``"LL in zig zag fashion : "``);` `        ``lobj.printLL();` `    ``}` `}`

## Python3

 `# Python program for the above approach// Node class` `class` `Node:`   `    ``# Constructor to initialize the node object` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`     `head ``=` `None`   `# Print Linked List`     `def` `printLL():` `    ``t ``=` `head` `    ``while` `(t !``=` `None``):` `        ``print``(t.data, end``=``" ->"``)` `        ``t ``=` `t.``next` `    ``print``()`   `# Swap both nodes`     `def` `swap(a, b):` `    ``if``(a ``=``=` `None` `or` `b ``=``=` `None``):` `        ``return` `    ``temp ``=` `a.data` `    ``a.data ``=` `b.data` `    ``b.data ``=` `temp`   `# Rearrange the linked list` `# in zig zag way`     `def` `zigZag(node, flag):` `    ``if``(node ``=``=` `None` `or` `node.``next` `=``=` `None``):` `        ``return` `node` `    ``if` `(flag ``=``=` `0``):` `        ``if` `(node.data > node.``next``.data):` `            ``swap(node, node.``next``)` `        ``return` `zigZag(node.``next``, ``1``)`   `    ``else``:` `        ``if` `(node.data < node.``next``.data):` `            ``swap(node, node.``next``)` `        ``return` `zigZag(node.``next``, ``0``)`     `# Driver Code` `head ``=` `Node(``11``)` `head.``next` `=` `Node(``15``)` `head.``next``.``next` `=` `Node(``20``)` `head.``next``.``next``.``next` `=` `Node(``5``)` `head.``next``.``next``.``next``.``next` `=` `Node(``10``)` `printLL()`   `# 0 means the current element` `# should be smaller than the next` `flag ``=` `0` `zigZag(head, flag)` `print``(``"LL in zig zag fashion : "``)` `printLL()`   `# This code is contributed by avanitrachhadiya2155.`

## C#

 `// C# program for the above approach` `using` `System;`   `// Node class` `public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node next;` `    ``public`   `        ``Node(``int` `data)` `    ``{` `        ``this``.data = data;` `    ``}` `}`   `public` `class` `GFG {`   `    ``private` `Node head;`   `    ``// Print Linked List` `    ``public` `void` `printLL()` `    ``{` `        ``Node t = head;` `        ``while` `(t != ``null``) {` `            ``Console.Write(t.data + ``" ->"``);` `            ``t = t.next;` `        ``}` `        ``Console.WriteLine();` `    ``}`   `    ``// Swap both nodes` `    ``public` `void` `swap(Node a, Node b)` `    ``{` `        ``if` `(a == ``null` `|| b == ``null``)` `            ``return``;` `        ``int` `temp = a.data;` `        ``a.data = b.data;` `        ``b.data = temp;` `    ``}`   `    ``// Rearrange the linked list` `    ``// in zig zag way` `    ``public` `Node zigZag(Node node, ``int` `flag)` `    ``{` `        ``if` `(node == ``null` `|| node.next == ``null``) {` `            ``return` `node;` `        ``}` `        ``if` `(flag == 0) {` `            ``if` `(node.data > node.next.data) {` `                ``swap(node, node.next);` `            ``}` `            ``return` `zigZag(node.next, 1);` `        ``}` `        ``else` `{` `            ``if` `(node.data < node.next.data) {` `                ``swap(node, node.next);` `            ``}` `            ``return` `zigZag(node.next, 0);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``GFG lobj = ``new` `GFG();` `        ``lobj.head = ``new` `Node(11);` `        ``lobj.head.next = ``new` `Node(15);` `        ``lobj.head.next.next = ``new` `Node(20);` `        ``lobj.head.next.next.next = ``new` `Node(5);` `        ``lobj.head.next.next.next.next = ``new` `Node(10);` `        ``lobj.printLL();`   `        ``// 0 means the current element` `        ``// should be smaller than the next` `        ``int` `flag = 0;` `        ``lobj.zigZag(lobj.head, flag);` `        ``Console.WriteLine(``"LL in zig zag fashion : "``);` `        ``lobj.printLL();` `    ``}` `}`   `// This code is contributed by umadevi9616`

## Javascript

 ``

Output

```11 ->15 ->20 ->5 ->10 ->
LL in zig zag fashion :
11 ->20 ->5 ->15 ->10 ->```

Complexity Analysis:

• Time Complexity: O(n).
Traversal of the list is done only once, and it has ‘n’ elements.
• Auxiliary Space: O(n).
O(n) extra space data structure for storing values.