排序已按绝对值排序的链表

给定一个基于绝对值排序的链表。根据实际值对列表进行排序。
例子：

Input :  1 -> -10 
output: -10 -> 1

Input : 1 -> -2 -> -3 -> 4 -> -5 
output: -5 -> -3 -> -2 -> 1 -> 4 

Input : -5 -> -10 
Output: -10 -> -5

Input : 5 -> 10 
output: 5 -> 10

来源：亚马逊专访

一个简单的解决方案是从头到尾遍历链表。对于每个访问过的节点，检查它是否乱序。如果是，请将其从当前位置移除并插入到正确位置。这是链表插入排序的实现，该方案的时间复杂度为O(n*n)。
更好的解决方案是使用归并排序对链表进行排序。该解决方案的时间复杂度为 O(n Log n)。
一个有效的解决方案可以在 O(n) 时间内工作。一个重要的观察结果是，所有负面元素都以相反的顺序存在。所以我们遍历链表，每当发现一个乱序的元素，就将它移到链表的最前面。
下面是上述想法的实现。

C++

// C++ program to sort a linked list, already
// sorted by absolute values
#include 
using namespace std;
 
// Linked List Node
struct Node
{
    Node* next;
    int data;
};
 
// Utility function to insert a node at the
// beginning
void push(Node** head, int data)
{
    Node* newNode = new Node;
    newNode->next = (*head);
    newNode->data = data;
    (*head) = newNode;
}
 
// Utility function to print a linked list
void printList(Node* head)
{
    while (head != NULL)
    {
        cout << head->data;
        if (head->next != NULL)
            cout << " -> ";
        head = head->next;
    }
    cout<next;
 
    // Traverse list
    while (curr != NULL)
    {
        // If curr is smaller than prev, then
        // it must be moved to head
        if (curr->data < prev->data)
        {
            // Detach curr from linked list
            prev->next = curr->next;
 
            // Move current node to beginning
            curr->next = (*head);
            (*head) = curr;
 
            // Update current
            curr = prev;
        }
 
        // Nothing to do if current element
        // is at right place
        else
            prev = curr;
 
        // Move current
        curr = curr->next;
    }
}
 
// Driver code
int main()
{
    Node* head = NULL;
    push(&head, -5);
    push(&head, 5);
    push(&head, 4);
    push(&head, 3);
    push(&head, -2);
    push(&head, 1);
    push(&head, 0);
 
    cout << "Original list :\n";
    printList(head);
 
    sortList(&head);
 
    cout << "\nSorted list :\n";
    printList(head);
 
    return 0;
}

Java

// Java program to sort a linked list, already
// sorted by absolute values
class SortList
{
    static Node head;  // head of list
   
    /* Linked list Node*/
    static class Node
    {
        int data;
        Node next;
        Node(int d) {data = d; next = null; }
    }
     
    // To sort a linked list by actual values.
        // The list is assumed to be sorted by absolute
        // values.
    Node sortedList(Node head)
    {
        // Initialize previous and current nodes
        Node prev = head;
        Node curr = head.next;
         
        // Traverse list
        while(curr != null)
        {
            // If curr is smaller than prev, then
                        // it must be moved to head
            if(curr.data < prev.data)
            {
                // Detach curr from linked list
                prev.next = curr.next;
                 
                // Move current node to beginning
                curr.next = head;
                head = curr;
                 
                // Update current
                curr = prev;
            }
             
            // Nothing to do if current element
                        // is at right place
            else
            prev = curr;
         
            // Move current
            curr = curr.next;
        }
        return head;
    }
     
    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);
   
        /* 3. Make next of new Node as head */
        new_node.next = head;
   
        /* 4. Move the head to point to new Node */
        head = new_node;
    }
     
    /* Function to print linked list */
    void printList(Node head)
    {
        Node temp = head;
        while (temp != null)
        {
           System.out.print(temp.data+" ");
           temp = temp.next;
        } 
        System.out.println();
    }
     
    /* Driver program to test above functions */
    public static void main(String args[])
    {
        SortList llist = new SortList();
          
        /* Constructed Linked List is 1->2->3->4->5->6->
           7->8->8->9->null */
        llist.push(-5);
        llist.push(5);
        llist.push(4);
        llist.push(3);
        llist.push(-2);
        llist.push(1);
        llist.push(0);
          
        System.out.println("Original List :");
        llist.printList(llist.head);
          
        llist.head = llist.sortedList(head);
  
        System.out.println("Sorted list :");
        llist.printList(llist.head);
    }
}
 
// This code has been contributed by Amit Khandelwal(Amit Khandelwal 1).

Python3

# Python3 program to sort a linked list,
# already sorted by absolute values
     
# Linked list Node
class Node:
    def __init__(self, d):
        self.data = d
        self.next = None
 
class SortList:
    def __init__(self):
        self.head = None
         
    # To sort a linked list by actual values.
    # The list is assumed to be sorted by
    # absolute values.
    def sortedList(self, head):
         
        # Initialize previous and
        # current nodes
        prev = self.head
        curr = self.head.next
         
        # Traverse list
        while(curr != None):
             
            # If curr is smaller than prev,
            # then it must be moved to head
            if(curr.data < prev.data):
                 
                # Detach curr from linked list
                prev.next = curr.next
                 
                # Move current node to beginning
                curr.next = self.head
                self.head = curr
                 
                # Update current
                curr = prev
             
            # Nothing to do if current element
            # is at right place
            else:
                prev = curr
         
            # Move current
            curr = curr.next
        return self.head
     
    # Inserts a new Node at front of the list
    def push(self, new_data):
         
        # 1 & 2: Allocate the Node &
        #        Put in the data
        new_node = Node(new_data)
     
        # 3. Make next of new Node as head
        new_node.next = self.head
     
        # 4. Move the head to point to new Node
        self.head = new_node
     
    # Function to print linked list
    def printList(self, head):
        temp = head
        while (temp != None):
            print(temp.data, end = " ")
            temp = temp.next
        print()
     
# Driver Code
llist = SortList()
 
# Constructed Linked List is 
# 1->2->3->4->5->6->7->8->8->9->null
llist.push(-5)
llist.push(5)
llist.push(4)
llist.push(3)
llist.push(-2)
llist.push(1)
llist.push(0)
         
print("Original List :")
llist.printList(llist.head)
         
start = llist.sortedList(llist.head)
 
print("Sorted list :")
llist.printList(start)
 
# This code is contributed by
# Prerna Saini

C#

// C# program to sort a linked list, already
// sorted by absolute values
using System;
 
public class SortList
{
    Node head; // head of list
     
    /* Linked list Node*/
    class Node
    {
        public int data;
        public Node next;
        public Node(int d)
        {
            data = d; next = null;
        }
    }
     
    // To sort a linked list by actual values.
    // The list is assumed to be sorted by absolute
    // values.
    Node sortedList(Node head)
    {
        // Initialize previous and current nodes
        Node prev = head;
        Node curr = head.next;
         
        // Traverse list
        while(curr != null)
        {
            // If curr is smaller than prev, then
            // it must be moved to head
            if(curr.data < prev.data)
            {
                // Detach curr from linked list
                prev.next = curr.next;
                 
                // Move current node to beginning
                curr.next = head;
                head = curr;
                 
                // Update current
                curr = prev;
            }
             
            // Nothing to do if current element
            // is at right place
            else
            prev = curr;
         
            // Move current
            curr = curr.next;
        }
        return head;
    }
     
    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                Put in the data*/
        Node new_node = new Node(new_data);
     
        /* 3. Make next of new Node as head */
        new_node.next = head;
     
        /* 4. Move the head to point to new Node */
        head = new_node;
    }
     
    /* Function to print linked list */
    void printList(Node head)
    {
        Node temp = head;
        while (temp != null)
        {
        Console.Write(temp.data + " ");
        temp = temp.next;
        }
        Console.WriteLine();
    }
     
    /* Driver code */
    public static void Main(String []args)
    {
        SortList llist = new SortList();
         
        /* Constructed Linked List is 1->2->3->
        4->5->6->7->8->8->9->null */
        llist.push(-5);
        llist.push(5);
        llist.push(4);
        llist.push(3);
        llist.push(-2);
        llist.push(1);
        llist.push(0);
         
        Console.WriteLine("Original List :");
        llist.printList(llist.head);
         
        llist.head = llist.sortedList(llist.head);
 
        Console.WriteLine("Sorted list :");
        llist.printList(llist.head);
    }
}
 
/* This code is contributed by 29AjayKumar */

Javascript

 
// Javascript program to sort a linked list, already
// sorted by absolute values
 
    var head; // head of list
 
    /* Linked list Node */
     class Node {
            constructor(d) {
                this.data = d;
                this.next = null;
            }
        }
 
    // To sort a linked list by actual values.
    // The list is assumed to be sorted by absolute
    // values.
    function sortedList(head) {
        // Initialize previous and current nodes
    var prev = head;
    var curr = head.next;
 
        // Traverse list
        while (curr != null) {
            // If curr is smaller than prev, then
            // it must be moved to head
            if (curr.data < prev.data) {
                // Detach curr from linked list
                prev.next = curr.next;
 
                // Move current node to beginning
                curr.next = head;
                head = curr;
 
                // Update current
                curr = prev;
            }
 
            // Nothing to do if current element
            // is at right place
            else
                prev = curr;
 
            // Move current
            curr = curr.next;
        }
        return head;
    }
 
    /* Inserts a new Node at front of the list. */
     function push(new_data) {
        /*
         * 1 & 2: Allocate the Node & Put in the data
         */
var new_node = new Node(new_data);
 
        /* 3. Make next of new Node as head */
        new_node.next = head;
 
        /* 4. Move the head to point to new Node */
        head = new_node;
    }
 
    /* Function to print linked list */
    function printList(head) {
var temp = head;
        while (temp != null) {
            document.write(temp.data + " ");
            temp = temp.next;
        }
        document.write("<br/>");
    }
 
    /* Driver program to test above functions */
     
     
        /*
          Constructed Linked List is
         1->2->3->4->5->6-> 7->8->8->9->null
         */
        push(-5);
        push(5);
        push(4);
        push(3);
        push(-2);
        push(1);
        push(0);
 
        document.write("Original List :<br/>");
        printList(head);
 
        head = sortedList(head);
 
        document.write("Sorted list :<br/>");
        printList(head);
 
// This code contributed by aashish1995
 

输出：

Original list :
0 -> 1 -> -2 -> 3 -> 4 -> 5 -> -5

Sorted list :
-5 -> -2 -> 0 -> 1 -> 3 -> 4 -> 5

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