以波形形式对链表进行排序

给定一个未排序的整数链表。任务是将 Linked List 排序为类似 Line 的 wave。如果排序后的列表为以下形式，则称链表以波形形式排序：

list[0] >= list[1] <= list[2] >= …..

其中 list[i] 表示链表第 i 个节点的数据。

例子：

Input : List = 2 -> 4 -> 6 -> 8 -> 10 -> 20
Output : 4 -> 2 -> 8 -> 6 -> 20 -> 10

Input : List = 3 -> 6 -> 5 -> 10 -> 7 -> 20
Output : 6 -> 3 -> 10 -> 5 -> 20 -> 7

一个简单的解决方案是使用排序。首先对输入的链表进行排序，然后交换所有相邻元素。
例如，让输入列表为3 -> 6 -> 5 -> 10 -> 7 -> 20 。排序后，我们得到3 -> 5 -> 6 -> 7 -> 10 -> 20 。交换相邻元素后，我们得到5 -> 3 -> 7 -> 6 -> 20 -> 10这是所需的波形列表。

时间复杂度：O(N*logN)，其中 N 是列表中的节点数。

有效的解决方案：这可以通过对给定列表进行一次遍历在 O(n) 时间内完成。这个想法是基于这样一个事实，如果我们确保所有偶数定位（在索引 0、2、4、..）元素都大于它们相邻的奇数元素，我们就不需要担心奇数定位的元素。以下是简单的步骤。

注意：假设列表中的索引从零开始。也就是说，list[0] 表示链表的第一个元素。

遍历输入链表的所有偶数定位元素，并执行以下操作。

• 如果当前元素小于前一个奇数元素，则交换前一个和当前元素。
• 如果当前元素小于下一个奇数元素，则交换下一个和当前元素。

下面是上述方法的实现：

C++

// C++ program to sort linked list
// in wave form
#include 
#include 
 
using namespace std;
 
// A linked list node
struct Node {
    int data;
    struct Node* next;
};
 
// Function to add a node at the
// beginning of Linked List
void push(struct Node** head_ref, int new_data)
{
    /* allocate node */
    struct Node* new_node = (struct Node*)malloc(sizeof(struct 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 get size of the list
int listSize(struct Node* node)
{
    int c = 0;
 
    while (node != NULL) {
        c++;
 
        node = node->next;
    }
 
    return c;
}
 
// Function to print the list
void printList(struct Node* node)
{
    while (node != NULL) {
        cout << node->data << " ";
 
        node = node->next;
    }
}
 
/* UTILITY FUNCTIONS */
/* Function to swap two integers */
void swap(int* a, int* b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}
 
// Function to sort linked list in
// wave form
void sortInWave(struct Node* head)
{
    struct Node* current = head;
    struct Node* prev = NULL;
 
    // Variable to track even position
    int i = 0;
 
    // Size of list
    int n = listSize(head);
 
    // Traverse all even positioned nodes
    while (i < n) {
 
        if (i % 2 == 0) {
            // If current even element is
            // smaller than previous
            if (i > 0 && (prev->data > current->data))
                swap(&(current->data), &(prev->data));
 
            // If current even element is
            // smaller than next
            if (i < n - 1 && (current->data < current->next->data))
                swap(&(current->data), &(current->next->data));
        }
 
        i++;
 
        prev = current;
        current = current->next;
    }
}
 
// Driver program to test above function
int main()
{
    struct Node* start = NULL;
 
    /* The constructed linked list is:
    10, 90, 49, 2, 1, 5, 23*/
    push(&start, 23);
    push(&start, 5);
    push(&start, 1);
    push(&start, 2);
    push(&start, 49);
    push(&start, 90);
    push(&start, 10);
 
    sortInWave(start);
 
    printList(start);
 
    return 0;
}

Java

// Java program to sort linked list
// in wave form
class GFG
{
     
// A linked list node
static class Node
{
    int data;
    Node next;
};
 
// Function to add a node at the
// beginning of Linked List
static Node push(Node head_ref, 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_ref);
 
    /* move the head to point to the new node */
    (head_ref) = new_node;
    return head_ref;
}
 
// Function get size of the list
static int listSize( Node node)
{
    int c = 0;
    while (node != null)
    {
        c++;
        node = node.next;
    }
    return c;
}
 
// Function to print the list
static void printList( Node node)
{
    while (node != null)
    {
        System.out.print(node.data + " ");
        node = node.next;
    }
}
 
// Function to sort linked list in
// wave form
static Node sortInWave( Node head)
{
    Node current = head;
    Node prev = null;
 
    // Variable to track even position
    int i = 0;
 
    // Size of list
    int n = listSize(head);
 
    // Traverse all even positioned nodes
    while (i < n)
    {
        if (i % 2 == 0)
        {
            // If current even element is
            // smaller than previous
            if (i > 0 && (prev.data > current.data))
            {
                int t = prev.data;
                prev.data = current.data;
                current.data = t;
            }
                 
            // If current even element is
            // smaller than next
            if (i < n - 1 && (current.data <
                              current.next.data))
            {
                int t = current.next.data;
                current.next.data = current.data;
                current.data = t;
            }
        }
        i++;
 
        prev = current;
        current = current.next;
    }
    return head;
}
 
// Driver Code
public static void main(String args[])
{
    Node start = null;
 
    /* The constructed linked list is:
    10, 90, 49, 2, 1, 5, 23*/
    start = push(start, 23);
    start = push(start, 5);
    start = push(start, 1);
    start = push(start, 2);
    start = push(start, 49);
    start = push(start, 90);
    start = push(start, 10);
 
    start = sortInWave(start);
 
    printList(start);
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 program to sort linked list
# in wave form
  
# A linked list node
class Node:
     
    def __init__(self):
         
        self.data = 0
        self.next = None
 
# Function to add a node at the
# beginning of Linked List
def push( head_ref, new_data):
 
    ''' allocate node '''
    new_node = 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;
     
    return head_ref
  
# Function get size of the list
def listSize(node):
 
    c = 0;
  
    while (node != None):
        c += 1
  
        node = node.next;
  
    return c;
  
# Function to print the list
def printList(node):
 
    while (node != None):
         
        print(node.data, end = ' ')
  
        node = node.next;
  
# Function to sort linked list in
# wave form
def sortInWave(head):
 
    current = head;
    prev = None;
  
    # Variable to track even position
    i = 0;
  
    # Size of list
    n = listSize(head);
  
    # Traverse all even positioned nodes
    while (i < n):
  
        if (i % 2 == 0):
     
            # If current even element is
            # smaller than previous
            if (i > 0 and (prev.data > current.data)):
                (current.data), (prev.data) = (prev.data), (current.data)
  
            # If current even element is
            # smaller than next
            if (i < n - 1 and (current.data < current.next.data)):
                (current.data), (current.next.data) = (current.next.data), (current.data)
  
        i += 1
  
        prev = current;
        current = current.next;
      
# Driver program to test above function
if __name__=='__main__':
     
    start = None;
  
    ''' The constructed linked list is:
    10, 90, 49, 2, 1, 5, 23'''
    start = push(start, 23);
    start = push(start, 5);
    start = push(start, 1);
    start = push(start, 2);
    start = push(start, 49);
    start = push(start, 90);
    start = push(start, 10)
  
    sortInWave(start)
  
    printList(start);
  
# This code is contributed by pratham76

C#

// C# program to sort linked list
// in wave form
using System;
 
class GFG{
     
// A linked list node
class Node
{
    public int data;
    public Node next;
};
 
// Function to add a node at the
// beginning of Linked List
static Node push(Node head_ref, 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_ref);
 
    // Move the head to point to the new node
    (head_ref) = new_node;
    return head_ref;
}
 
// Function get size of the list
static int listSize( Node node)
{
    int c = 0;
     
    while (node != null)
    {
        c++;
        node = node.next;
    }
    return c;
}
 
// Function to print the list
static void printList( Node node)
{
    while (node != null)
    {
        Console.Write(node.data + " ");
        node = node.next;
    }
}
 
// Function to sort linked list in
// wave form
static Node sortInWave( Node head)
{
    Node current = head;
    Node prev = null;
 
    // Variable to track even position
    int i = 0;
 
    // Size of list
    int n = listSize(head);
 
    // Traverse all even positioned nodes
    while (i < n)
    {
        if (i % 2 == 0)
        {
             
            // If current even element is
            // smaller than previous
            if (i > 0 && (prev.data >
                          current.data))
            {
                int t = prev.data;
                prev.data = current.data;
                current.data = t;
            }
                 
            // If current even element is
            // smaller than next
            if (i < n - 1 && (current.data <
                              current.next.data))
            {
                int t = current.next.data;
                current.next.data = current.data;
                current.data = t;
            }
        }
        i++;
 
        prev = current;
        current = current.next;
    }
    return head;
}
 
// Driver Code
public static void Main(string []args)
{
    Node start = null;
 
    // The constructed linked list is:
    // 10, 90, 49, 2, 1, 5, 23
    start = push(start, 23);
    start = push(start, 5);
    start = push(start, 1);
    start = push(start, 2);
    start = push(start, 49);
    start = push(start, 90);
    start = push(start, 10);
 
    start = sortInWave(start);
 
    printList(start);
}
}
 
// This code is contributed by rutvik_56

Javascript

 
      // JavaScript program to sort linked list
      // in wave form
      // A linked list node
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }
 
      // Function to add a node at the
      // beginning of Linked List
      function push(head_ref, 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_ref;
 
        // Move the head to point to the new node
        head_ref = new_node;
        return head_ref;
      }
 
      // Function get size of the list
      function listSize(node) {
        var c = 0;
 
        while (node != null) {
          c++;
          node = node.next;
        }
        return c;
      }
 
      // Function to print the list
      function printList(node) {
        while (node != null) {
          document.write(node.data + " ");
          node = node.next;
        }
      }
 
      // Function to sort linked list in
      // wave form
      function sortInWave(head) {
        var current = head;
        var prev = null;
 
        // Variable to track even position
        var i = 0;
 
        // Size of list
        var n = listSize(head);
 
        // Traverse all even positioned nodes
        while (i < n) {
          if (i % 2 == 0) {
            // If current even element is
            // smaller than previous
            if (i > 0 && prev.data > current.data) {
              var t = prev.data;
              prev.data = current.data;
              current.data = t;
            }
 
            // If current even element is
            // smaller than next
            if (i < n - 1 && current.data < current.next.data) {
              var t = current.next.data;
              current.next.data = current.data;
              current.data = t;
            }
          }
          i++;
 
          prev = current;
          current = current.next;
        }
        return head;
      }
 
      // Driver Code
      var start = null;
 
      // The constructed linked list is:
      // 10, 90, 49, 2, 1, 5, 23
      start = push(start, 23);
      start = push(start, 5);
      start = push(start, 1);
      start = push(start, 2);
      start = push(start, 49);
      start = push(start, 90);
      start = push(start, 10);
 
      start = sortInWave(start);
 
      printList(start);
       

输出：

90 10 49 1 5 2 23

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