以 Zig-Zag 方式重新排列链表

给定一个链表，重新排列它，使得转换后的列表应该是 a < b > c < d > e < f ... 其中 a, b, c ... 是链表的连续数据节点。

例子：

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 

我们强烈建议您在继续解决方案之前单击此处进行练习。

一个简单的方法是使用合并排序对链表进行排序，然后交换交替，但这需要 O(n Log n) 时间复杂度。这里 n 是链表中的元素数量。

一种需要 O(n) 时间的有效方法是，使用类似于冒泡排序的单次扫描，然后维护一个标志来表示我们当前是哪个订单 ()。如果当前的两个元素不在该顺序中，则交换这些元素，否则不会。有关交换顺序的详细说明，请参阅此处。

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 off 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);
}

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 off 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 zac 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 off 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

 
// Javascript program to arrange
// linked list in zigzag fashion
 
    /* Link list Node */
     class Node {
            constructor() {
                this.data = 0;
                this.next = null;
            }
        }
 
    var head = null;
    var temp = 0;
 
    // This function distributes
    // the Node in zigzag fashion
    function zigZagList(head) {
        // If flag is true, then
        // next node should be greater
        // in the desired output.
        var flag = true;
 
        // Traverse linked list starting from head.
        var 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 */
    function push(new_data) {
        /* allocate Node */
        var new_Node = new Node();
 
        /* put in the data */
        new_Node.data = new_data;
 
        /* link the old list off the new Node */
        new_Node.next = (head);
 
        /* move the head to povar to the new Node */
        (head) = new_Node;
    }
 
    /* Function to prvar linked list */
    function printList(node) {
        while (node != null) {
            document.write(node.data + "->");
    node = node.next;
        }
        document.write("NULL<br/>");
    }
 
    /* Driver code */
     
        /* 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);
 
        document.write("Given linked list <br/>");
        printList(head);
 
        zigZagList(head);
 
        document.write("Zig Zag Linked list <br/>");
        printList(head);
 
// This code contributed by gauravrajput1
 

输出

Given linked list 
4->3->7->8->6->2->1->NULL
Zig Zag Linked list 
3->7->4->8->2->6->1->NULL

另一种方法：
在上面的代码中，push函数推送链表最前面的节点，代码可以很方便的修改为推送链表末尾的节点。另一件需要注意的事情是，两个节点之间的数据交换是通过值交换而不是链接交换来完成的，为简单起见，对于链接交换技术，请参阅this。

这也可以递归完成。想法保持不变，让我们假设标志的值决定了我们需要检查以比较当前元素的条件。因此，如果标志为 0（或 false），则当前元素应小于下一个，如果标志为 1（或 true），则当前元素应大于下一个。如果不是，交换节点的值。

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();
    }
}

蟒蛇3

# 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
 
# Prvar 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

// javascript program for the above approach// Node class
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
 
var head;
 
    // Prvar Linked List
     function printLL() {
var t = head;
        while (t != null) {
            document.write(t.data + " ->");
            t = t.next;
        }
        document.write();
    }
 
    // Swap both nodes
     function swap(a,  b) {
        if (a == null || b == null)
            return;
        var temp = a.data;
        a.data = b.data;
        b.data = temp;
    }
 
    // Rearrange the linked list
    // in zig zag way
     function zigZag(node , 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
     
        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);
        printLL();
 
        // 0 means the current element
        // should be smaller than the next
        var flag = 0;
        zigZag(head, flag);
        document.write("<br/>LL in zig zag fashion : <br/>");
        printLL();
 
// This code contributed by umadevi9616

输出

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

复杂度分析：

• 时间复杂度： O(n)。
  列表的遍历只完成一次，并且它有 'n' 个元素。
• 辅助空间： O(n)。
  O(n) 用于存储值的额外空间数据结构。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。