Rearrange a Linked List in Zig-Zag fashion

Last Updated : 28 May, 2026

Given the head of a linked list, rearrange the nodes to form a zig-zag pattern: a ≤ b ≥ c ≤ d ≥ e ≤ f ...  It means the first pair (a, b) is increasing, second pair (b, c)  is decreasing, third pair (c, d) is increasing and so on in the modified linked list.

  • Only swapping of adjacent nodes is allowed.
  • You may swap also already swapped adjacent but cannot swap two nodes which are not adjacent.

For example, for the linked list: 11 -> 15 -> 20 -> 5 -> 10

  • 11 -> 20 -> 5 -> 15 -> 10 is valid, while
  • 5 -> 20 -> 11 -> 15 -> 10 is invalid because it changes the relative order of nodes.

Return the head of the modified zig-zag linked list.

Examples: 

Input: head: 1 -> 2 -> 3 -> 4

1

Output: 1->3->2->4

2

Explanation: In the given linked list, after arranging them as 1 ≤ 3 ≥ 2 ≤ 4 in the pattern as asked above.

Input: head: 11 -> 15 -> 20 -> 5 -> 10

3

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

4

Explanation: In the given linked list, after arranging them as 11 ≤ 20 ≥ 5 ≤ 15 ≥ 10 in the pattern as asked above.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Repeated Traversal using Adjacent Swapping - O(n^2) Time O(1) Space

The idea is to repeatedly traverse the linked list and maintain the zig-zag pattern using a flag. If the current adjacent pair does not satisfy the required relation (≤ or ≥), swap their data values. Continue this process until no swaps are needed in a complete traversal.

C++ 
#include <bits/stdc++.h>
using namespace std;

// Structure of linked list node
class Node
{
  public:
    int data;
    Node *next;

    Node(int x)
    {
        data = x;
        next = nullptr;
    }
};

Node *zigZag(Node *head)
{

    if (head == nullptr)
        return head;

    bool swapped = true;

    // Repeat until no swaps are needed
    while (swapped)
    {

        swapped = false;

        Node *current = head;

        bool flag = true;

        // Traverse linked list
        while (current!= nullptr && current->next!= nullptr)
        {

            // If flag is true, next element
            // should be greater than current
            if (flag)
            {

                if (current->data > current->next->data)
                {
                    swap(current->data, current->next->data);
                    swapped = true;
                }
            }

            // If flag is false, next element
            // should be smaller than current
            else
            {

                if (current->data < current->next->data)
                {
                    swap(current->data, current->next->data);
                    swapped = true;
                }
            }

            current = current->next;

            // Flip flag for alternate checking
            flag = !flag;
        }
    }

    return head;
}

// Driver code
int main()
{

    // LinkedList: 11->15->20->5->10
    Node *head = new Node(11);
    head->next = new Node(15);
    head->next->next = new Node(20);
    head->next->next->next = new Node(5);
    head->next->next->next->next = new Node(10);

    head = zigZag(head);

    Node* current = head;
    while(current!= nullptr) {
        cout << current->data << " ";
        current = current->next;
    }

    return 0;
}
Java 
import java.util.*;

// Structure of linked list node
class Node {
    public int data;
    public Node next;

    Node(int x)
    {
        data = x;
        next = null;
    }
};

public class GfG {

    // Function to rearrange linked list in zig-zag fashion
    static Node zigZag(Node head)
    {

        if (head == null)
            return head;

        boolean swapped = true;

        // Repeat until no swaps are needed
        while (swapped) {

            swapped = false;

            Node current = head;

            boolean flag = true;

            // Traverse linked list
            while (current!= null
                   && current.next!= null) {

                // If flag is true, next element
                // should be greater than current
                if (flag) {

                    if (current.data > current.next.data) {
                        int temp = current.data;
                        current.data = current.next.data;
                        current.next.data = temp;
                        swapped = true;
                    }
                }

                // If flag is false, next element
                // should be smaller than current
                else {

                    if (current.data < current.next.data) {
                        int temp = current.data;
                        current.data = current.next.data;
                        current.next.data = temp;
                        swapped = true;
                    }
                }

                current = current.next;

                // Flip flag for alternate checking
                flag = !flag;
            }
        }

        return head;
    }

    // Driver code
    public static void main(String[] args)
    {

        // LinkedList: 11->15->20->5->10
        Node head = new Node(11);
        head.next = new Node(15);
        head.next.next = new Node(20);
        head.next.next.next = new Node(5);
        head.next.next.next.next = new Node(10);

        head = zigZag(head);

        Node current = head;
        while (current!= null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
    }
}
Python 
# Structure of linked list node
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# Function to rearrange linked list in zig-zag fashion

def zigZag(head):
    if head is None:
        return head

    swapped = True

    # Repeat until no swaps are needed
    while swapped:
        swapped = False

        current = head

        flag = True

        # Traverse linked list
        while current is not None and current.next is not None:
            # If flag is true, next element
            # should be greater than current
            if flag:
                if current.data > current.next.data:
                    current.data, current.next.data = current.next.data, current.data
                    swapped = True
            # If flag is false, next element
            # should be smaller than current
            else:
                if current.data < current.next.data:
                    current.data, current.next.data = current.next.data, current.data
                    swapped = True

            current = current.next

            # Flip flag for alternate checking
            flag = not flag

    return head

# Driver code
if __name__ == '__main__':
    # LinkedList: 11->15->20->5->10
    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)

    head = zigZag(head)

    # Print the rearranged linked list
    current = head
    while current is not None:
        print(current.data, end=' ')
        current = current.next
C# 
using System;

// Structure of linked list node
public class Node {
    public int data;
    public Node next;

    public Node(int x)
    {
        data = x;
        next = null;
    }
}

public class GfG {
    public static Node zigZag(Node head)
    {
        if (head == null)
            return head;

        bool swapped = true;

        // Repeat until no swaps are needed
        while (swapped) {
            swapped = false;

            Node current = head;

            bool flag = true;

            // Traverse linked list
            while (current!= null
                   && current.next!= null) {
                // If flag is true, next element
                // should be greater than current
                if (flag) {
                    if (current.data > current.next.data) {
                        int temp = current.data;
                        current.data = current.next.data;
                        current.next.data = temp;
                        swapped = true;
                    }
                }

                // If flag is false, next element
                // should be smaller than current
                else {
                    if (current.data < current.next.data) {
                        int temp = current.data;
                        current.data = current.next.data;
                        current.next.data = temp;
                        swapped = true;
                    }
                }

                current = current.next;

                // Flip flag for alternate checking
                flag = !flag;
            }
        }

        return head;
    }

    // Driver code
    public static void Main()
    {
        // LinkedList: 11->15->20->5->10
        Node head = new Node(11);
        head.next = new Node(15);
        head.next.next = new Node(20);
        head.next.next.next = new Node(5);
        head.next.next.next.next = new Node(10);

        head = zigZag(head);

        Node current = head;
        while (current!= null) {
            Console.Write(current.data + " ");
            current = current.next;
        }
    }
}
JavaScript 
// Structure of linked list node
class Node {
  constructor(x) {
    this.data = x;
    this.next = null;
  }
}

function zigZag(head) {
  if (head === null) return head;

  let swapped = true;

  // Repeat until no swaps are needed
  while (swapped) {
    swapped = false;

    let current = head;

    let flag = true;

    // Traverse linked list
    while (current!== null && current.next!== null) {
      // If flag is true, next element
      // should be greater than current
      if (flag) {
        if (current.data > current.next.data) {
          [current.data, current.next.data] = [current.next.data, current.data];
          swapped = true;
        }
      }

      // If flag is false, next element
      // should be smaller than current
      else {
        if (current.data < current.next.data) {
          [current.data, current.next.data] = [current.next.data, current.data];
          swapped = true;
        }
      }

      current = current.next;

      // Flip flag for alternate checking
      flag = !flag;
    }
  }

  return head;
}

// Driver code
// LinkedList: 11->15->20->5->10
let head = new Node(11);
head.next = new Node(15);
head.next.next = new Node(20);
head.next.next.next = new Node(5);
head.next.next.next.next = new Node(10);

head = zigZag(head);

let current = head;
while (current!== null) {
  console.log(current.data);
  current = current.next;
}

Output
true

Time Complexity: O(n^2)
Space Complexity: O(1)

[Expected Approach] Using Single Traversal using Flag - O(n) Time O(1) Space

The idea is to traverse the linked list once using a flag to maintain the zig-zag pattern. If the current pair does not satisfy the required relation (≤ or ≥), swap their data values and flip the flag for the next pair.

Let us understand with an example:
Input: head: 11 -> 15 -> 20 -> 5 -> 10
Compare 11 and 15 (<= needed), condition satisfied.

  • Compare 15 and 20 (>= needed), swap → 11 -> 20 -> 15 -> 5 -> 10
  • Compare 15 and 5 (<= needed), swap → 11 -> 20 -> 5 -> 15 -> 10
  • Compare 15 and 10 (>= needed), condition satisfied.

Final List: 11 -> 20 -> 5 -> 15 -> 10

C++ 
#include <bits/stdc++.h>
using namespace std;

// Structure of linked list node
class Node
{
  public:
    int data;
    Node *next;

    Node(int x)
    {
        data = x;
        next = nullptr;
    }
};

Node *zigZag(Node *head)
{

    bool flag = true;

    // Traverse linked list starting from head.
    Node *current = head;

    while (current!= nullptr && current->next!= nullptr)
    {

        if (flag)
        {

            // flag == true indicates next element
            // should be larger than current
            if (current->data > current->next->data)
                swap(current->data, current->next->data);
        }
        else
        {

            // flag == false indicates next element
            // should be smaller than current
            if (current->data < current->next->data)
                swap(current->data, current->next->data);
        }

        current = current->next;

        // Flip flag for reverse checking
        flag = !flag;
    }

    return head;
}

// Driver code
int main()
{

    // LinkedList: 11->15->20->5->10
    Node *head = new Node(11);
    head->next = new Node(15);
    head->next->next = new Node(20);
    head->next->next->next = new Node(5);
    head->next->next->next->next = new Node(10);

    head = zigZag(head);

    // Print list
    Node *current = head;
    while (current!= nullptr) {
        cout << current->data << " -> ";
        current = current->next;
    }
    cout << "NULL";

    return 0;
}
Java 
class Node {
    int data;
    Node next;

    Node(int x)
    {
        data = x;
        next = null;
    }
}

class GFG {
    static Node zigZag(Node head)
    {

        boolean flag = true;

        // Traverse linked list starting from head.
        Node current = head;

        while (current!= null && current.next!= null) {

            if (flag) {

                // flag == true indicates next element
                // should be larger than current
                if (current.data > current.next.data) {
                    int temp = current.data;
                    current.data = current.next.data;
                    current.next.data = temp;
                }
            }
            else {

                // flag == false indicates next element
                // should be smaller than current
                if (current.data < current.next.data) {
                    int temp = current.data;
                    current.data = current.next.data;
                    current.next.data = temp;
                }
            }

            current = current.next;

            // Flip flag for reverse checking
            flag = !flag;
        }

        return head;
    }

    // Driver code
    public static void main(String[] args)
    {

        // LinkedList: 11->15->20->5->10
        Node head = new Node(11);
        head.next = new Node(15);
        head.next.next = new Node(20);
        head.next.next.next = new Node(5);
        head.next.next.next.next = new Node(10);

        head = zigZag(head);

        // Print list
        Node current = head;
        while (current!= null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}
Python 
# Structure of linked list node
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None


def zigZag(head):

    flag = True

    # Traverse linked list starting from head.
    current = head

    while current is not None and current.next is not None:

        if flag:

            # flag == true indicates next element
            # should be larger than current
            if current.data > current.next.data:
                current.data, current.next.data = current.next.data, current.data
        else:

            # flag == false indicates next element
            # should be smaller than current
            if current.data < current.next.data:
                current.data, current.next.data = current.next.data, current.data

        current = current.next

        # Flip flag for reverse checking
        flag = not flag

    return head


# Driver code
if __name__ == "__main__":

    # LinkedList: 11->15->20->5->10
    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)

    head = zigZag(head)

    # Print the list
    current = head
    while current is not None:
        print(current.data, end=' ')
        current = current.next
    print()
C# 
using System;

class Node {
    public int data;
    public Node next;

    public Node(int x)
    {
        data = x;
        next = null;
    }
}

class GFG {
    static Node zigZag(Node head)
    {
        bool flag = true;

        // Traverse linked list starting from head.
        Node current = head;

        while (current!= null && current.next!= null) {

            if (flag) {

                // flag == true indicates next element
                // should be larger than current
                if (current.data > current.next.data) {
                    int temp = current.data;
                    current.data = current.next.data;
                    current.next.data = temp;
                }
            }
            else {

                // flag == false indicates next element
                // should be smaller than current
                if (current.data < current.next.data) {
                    int temp = current.data;
                    current.data = current.next.data;
                    current.next.data = temp;
                }
            }

            current = current.next;

            // Flip flag for reverse checking
            flag = !flag;
        }

        return head;
    }

    // Driver code
    static void Main()
    {

        // LinkedList: 11->15->20->5->10
        Node head = new Node(11);
        head.next = new Node(15);
        head.next.next = new Node(20);
        head.next.next.next = new Node(5);
        head.next.next.next.next = new Node(10);

        head = zigZag(head);

        Node current = head;
        while (current!= null) {
            Console.Write(current.data + " ");
            current = current.next;
        }
    }
}
JavaScript 
// Structure of linked list node
class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

function zigZag(head) {

    let flag = true;

    // Traverse linked list starting from head.
    let current = head;

    while (current!== null && current.next!== null) {

        if (flag) {

            // flag == true indicates next element
            // should be larger than current
            if (current.data > current.next.data) {
                [current.data, current.next.data] = [current.next.data, current.data];
            }
        } else {

            // flag == false indicates next element
            // should be smaller than current
            if (current.data < current.next.data) {
                [current.data, current.next.data] = [current.next.data, current.data];
            }
        }

        current = current.next;

        // Flip flag for reverse checking
        flag = !flag;
    }

    return head;
}

// Driver code
// LinkedList: 11->15->20->5->10
let head = new Node(11);
head.next = new Node(15);
head.next.next = new Node(20);
head.next.next.next = new Node(5);
head.next.next.next.next = new Node(10);

head = zigZag(head);

// Function to print the linked list
function printList(head) {
    let current = head;
    while (current!== null) {
        console.log(current.data);
        current = current.next;
    }
}

// Print the modified list
printList(head);

Output
true

Time Complexity: O(n)
Space Complexity: O(1)

Comment
Article Tags:
Linked List
DSA
Amazon

Explore