单链表上快速排序的 Javascript 程序

此处讨论双向链表上的快速排序。单链表上的快速排序作为练习给出。关于实现的重要事情是，它改变指针而不是交换数据，时间复杂度与双链表的实现相同。

在partition()中，我们将最后一个元素视为枢轴。我们遍历当前列表，如果一个节点的值大于枢轴，我们将其移动到尾部。如果节点的值较小，我们将其保持在当前位置。

在QuickSortRecur()中，我们首先调用 partition() ，它将枢轴放置在正确的位置并返回枢轴。枢轴放置在正确位置后，我们找到左侧的尾节点（枢轴之前的列表）并为左列表递归。最后，我们递归右列表。

Javascript

// Javascript program for Quick Sort on 
// Singly LinKed List
  
// Sort a linked list using quick sort
class Node 
{
    constructor(val) 
    {
        this.data = val;
        this.next = null;
    }
}
  
var head;
  
function addNode(data) 
{
    if (head == null) 
    {
        head = new Node(data);
        return;
    }
  
    var curr = head;
    while (curr.next != null)
        curr = curr.next;
  
    var newNode = new Node(data);
    curr.next = newNode;
}
  
function printList(n) 
{
    while (n != null) 
    {
        document.write(n.data);
        document.write(" ");
        n = n.next;
    }
}
  
// Takes first and last node,
// but do not break any links in
// the whole linked list
function paritionLast(start, end) 
{
    if (start == end || 
        start == null || 
        end == null)
        return start;
  
    var pivot_prev = start;
    var curr = start;
    var pivot = end.data;
  
    // Iterate till one before the end,
    // no need to iterate till the end
    // because end is pivot
    while (start != end) 
    {
        if (start.data < pivot) 
        {
            // Keep tracks of last modified 
            // item
            pivot_prev = curr;
            var temp = curr.data;
            curr.data = start.data;
            start.data = temp;
            curr = curr.next;
        }
        start = start.next;
    }
  
    // Swap the position of curr i.e.
    // next suitable index and pivot
    var temp = curr.data;
    curr.data = pivot;
    end.data = temp;
  
    // Return one previous to current
    // because current is now pointing
    // to pivot
    return pivot_prev;
}
  
function sort(start, end) 
{
    if (start == null || 
        start == end || 
        start == end.next)
            return;
  
    // Split list and partion recurse
    var pivot_prev = paritionLast(start, end);
    sort(start, pivot_prev);
  
    // If pivot is picked and moved to the start,
    // that means start and pivot is same
    // so pick from next of pivot
    if (pivot_prev != null && 
        pivot_prev == start)
        sort(pivot_prev.next, end);
  
    // If pivot is in between of the list,
    // start from next of pivot,
    // since we have pivot_prev, so we move two nodes
    else if (pivot_prev != null && 
             pivot_prev.next != null)
        sort(pivot_prev.next.next, end);
}
  
// Driver Code
addNode(30);
addNode(3);
addNode(4);
addNode(20);
addNode(5);
  
var n = head;
while (n.next != null)
    n = n.next;
  
document.write(
         "Linked List before sorting<br/>");
printList(head);
  
sort(head, n);
  
document.write(
         "<br/>Linked List after sorting<br/>");
printList(head);
// This code is contributed by umadevi9616 

输出：

Linked List before sorting 
30 3 4 20 5 
Linked List after sorting 
3 4 5 20 30 

有关详细信息，请参阅有关单链表快速排序的完整文章！