Quicksort on Doubly Linked List

Before implementing the Quicksort for a doubly-linked list, let's understand the quick sort. Quicksort is another sorting algorithm that is implemented using Divide and Conquers. Because of its high performance in the average situation (n log n), Quicksort is also a useful option of an algorithm for sorting. Unlike Merge Sort, Quicksort does not employ an additional array in its sorting process, and while its average case is the same as Merge Sort's, the hidden factors of (n log n) are often lower in the case of Quicksort.

Quicksort selects a pivot first and then partitions the array around it. All items smaller than the pivot are placed on one side, while all elements greater than it is placed on the opposite side. This partitioning procedure is repeated for the smaller sub-arrays, resulting in a sorted array. Selecting a pivot is the first step in partitioning. We'll always use the last member of the array as the pivot in our algorithm, and we'll concentrate on the Quicksort notions. The pivot can be chosen in various ways, including the median of the elements, the first member in the array, a random element, etc.

Following the pivot, we must arrange all elements smaller than the pivot on one side and all elements greater than the pivot on the other. We'll achieve this by iterating through the array and doing nothing.

If we encounter an element greater than the pivot, then a cluster of pieces larger than the pivot will form.
Any element smaller than the pivot will now be swapped with the first element of the bigger elements' cluster.
As a result, we'll create another cluster of smaller components than the pivot.
Finally, we'll exchange the pivot with the first member in the bigger element cluster.

C++ Code

Now let us write code to perform the sorting operation on the doubly linked list data structure with the help of a quicksort algorithm. First, let's write a C++ code to perform Quicksort on a doubly linked list data structure.

// A C++ program to sort a linked list using Quicksort  
#include <bits/stdc++.h> 
using namespace std; 
  
/* a node of the doubly linked list */
class Node  
{  
    public: 
    int data;  
    Node *next;  
    Node *prev;  
};  
  
/* A utility function to swap two elements */
void swap ( int* a, int* b )  
{ int t = *a; *a = *b; *b = t; }  
  
// A utility function to find 
// last node of linked list  
Node *lastNode(Node *root)  
{  
    while (root && root->next)  
        root = root->next;  
    return root;  
}  
  
/* Considers the last element as pivot,  
places the pivot element at its  
correct position in a sorted array,  
and places all smaller (smaller than  
pivot) to the left of the pivot and all greater 
elements to right of pivot */
Node* partition(Node *l, Node *h)  
{  
    // set pivot as h element  
    int x = h->data;  
  
    // similar to i = l-1 for array implementation  
    Node *i = l->prev;  
  
    // Similar to "for (int j = l; j <= h- 1; j++)"  
    for (Node *j = l; j != h; j = j->next)  
    {  
        if (j->data <= x)  
        {  
            // Similar to i++ for array  
            i = (i == NULL)? l : i->next;  
  
            swap(&(i->data), &(j->data));  
        }  
    }  
    i = (i == NULL)? l : i->next; // Similar to i++  
    swap(&(i->data), &(h->data));  
    return i;  
}  
  
/* A recursive implementation  
of quicksort for linked list */
void _quickSort(Node* l, Node *h)  
{  
    if (h != NULL && l != h && l != h->next)  
    {  
        Node *p = partition(l, h);  
        _quickSort(l, p->prev);  
        _quickSort(p->next, h);  
    }  
}  
  
// The main function to sort a linked list. 
// It mainly calls _quickSort()  
void quickSort(Node *head)  
{  
    // Find last node  
    Node *h = lastNode(head);  
  
    // Call the recursive QuickSort  
    _quickSort(head, h);  
}  
  
// A utility function to print contents of arr  
void printList(Node *head)  
{  
    while (head)  
    {  
        cout << head->data << " ";  
        head = head->next;  
    }  
    cout << endl;  
}  
  
/* Function to insert a node at the  
beginning of the Doubly Linked List */
void push(Node** head_ref, int new_data)  
{  
    Node* new_node = new Node; /* allocate node */
    new_node->data = new_data;  
  
    /* since we are adding at the 
    begining, prev is always NULL */
    new_node->prev = NULL;  
  
    /* link the old list off the new node */
    new_node->next = (*head_ref);  
  
    /* change prev of head node to new node */
    if ((*head_ref) != NULL) (*head_ref)->prev = new_node ;  
  
    /* move the head to point to the new node */
    (*head_ref) = new_node;  
}  
  
/* Driver code */
int main()  
{  
    Node *a = NULL;  
    int data;
    char ch;
        /*  Perform tree operations  */
        do    
        {
            cout<<"\nSelect one of the operations::"<<endl;
            cout<<"1. To insert a new node in the Doubly Linked List."<<endl;
            cout<<"2. To display the nodes of the Doubly Linked List."<<endl;
            cout<<"3. To perform Quicksort on the Doubly Linked List."<<endl;
             
            int choice;
            cin>>choice;            
            switch (choice)
            {
            case 1 : 
                cout<<"Enter the value of the node to be inserted"<<endl;
                cin>>data;
                push(&a,data);                     
                break;                          
            case 2 : 
                cout<<"Contents of the Doubly Linked List are::"<<endl;
                printList(a);
                break; 
            case 3 : 
                cout<<"Quicksort applied sucessfully on the Doubly Linked List."<<endl;
                quickSort(a);
                break;
            default : 
                cout<<"Wrong Entry \n ";
                break;   
            }
 
            cout<<"\nDo you want to continue (Type y or n) \n";
            cin>>ch;                        
        } while (ch == 'Y'|| ch == 'y');
    return 0;  
}  // end of main function

Output

The above code gives the following output.

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter the value of the node to be inserted
20

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter the value of the node to be inserted
30

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1 
Enter the value of the node to be inserted
12

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter the value of the node to be inserted
3

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1 
Enter the value of the node to be inserted
77

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter the value of the node to be inserted
54

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2
Contents of the Doubly Linked List are::
54 77 3 12 30 20 

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
3
Quicksort applied successfully on the Doubly Linked List.

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2
Contents of the Doubly Linked List are::
3 12 20 30 54 77 

Do you want to continue (Type y or n) 
n

In this way, we have written a C++ code to perform the quicksort operation on the doubly linked list data structure. There are three functions written for the doubly linked list data structure one is to add a new node in the doubly linked list, the second one is to display all the nodes of the doubly linked list and display the values associated with those nodes, and the third function is to perform the quicksort operation on the doubly linked list data structure.

The user first adds a sufficient amount of nodes in the doubly linked list data structure. Once the nodes are added successfully, the quicksort operation is performed on the doubly linked list data structure by selecting the third option from the menu displayed after each operation which will call the Quicksort () function written in the code to which pass the root node of the doubly linked list as a parameter.

After completing the quicksort operation, the user can confirm the result of the quicksort operation by displaying the values of the nodes in the doubly linked list by selecting the second option from the user. Once all the operations are done, the user can exit the code by entering the 'n' or 'N' character.

Java Code

Let's write a Java code to perform Quicksort on a doubly linked list data structure.

// A Java program to sort a linked list using Quicksort 

import java.util.Scanner;

class QuickSort_using_Doubly_LinkedList{ 
    Node head; 
    
/* a node of the doubly linked list */  
    static class Node{ 
        private int data; 
        private Node next; 
        private Node prev; 
          
        Node(int d){ 
            data = d; 
            next = null; 
            prev = null; 
        } 
    } 
      
// A utility function to find last node of linked list     
    Node lastNode(Node node){ 
        while(node.next!=null) 
            node = node.next; 
        return node; 
    } 
      
  
/* Considers the last element as pivot, places the pivot element at its 
   correct position in a sorted array, and places all smaller (smaller than 
   pivot) to the left of the pivot and all greater elements to right of pivot */
    Node partition(Node l, Node h) 
    { 
       // set pivot as h element 
        int x = h.data; 
          
        // similar to i = l-1 for array implementation 
        Node i = l.prev; 
          
        // Similar to "for (int j = l; j <= h- 1; j++)" 
        for(Node j=l; j!=h; j=j.next) 
        { 
            if(j.data <= x) 
            { 
                // Similar to i++ for array 
                i = (i==null) ? l : i.next; 
                int temp = i.data; 
                i.data = j.data; 
                j.data = temp; 
            } 
        } 
        i = (i==null) ? l : i.next;  // Similar to i++ 
        int temp = i.data; 
        i.data = h.data; 
        h.data = temp; 
        return i; 
    } 
      
    /* A recursive implementation of quicksort for linked list */
    void _quickSort(Node l,Node h) 
    { 
        if(h!=null && l!=h && l!=h.next){ 
            Node temp = partition(l,h); 
            _quickSort(l,temp.prev); 
            _quickSort(temp.next,h); 
        } 
    } 
      
    // The main function is to sort a linked list. It mainly calls _quickSort() 
    public void quickSort(Node node) 
    { 
        // Find last node 
        Node head = lastNode(node); 
          
        // Call the recursive QuickSort 
        _quickSort(node,head); 
    } 
      
     // A utility function to print contents of arr 
     public void printList(Node head) 
     { 
        while(head!=null){ 
            System.out.print(head.data+" "); 
            head = head.next; 
        } 
    } 
      
    /* Function to insert a node at the beginning of the Doubly Linked List */
    void push(int new_Data) 
    { 
        Node new_Node = new Node(new_Data);     /* allocate node */
          
        // if head is null, head = new_Node 
        if(head==null){ 
            head = new_Node; 
            return; 
        } 
          
        /* link the old list off the new node */
        new_Node.next = head; 
          
        /* change prev of head node to new node */
        head.prev = new_Node; 
          
        /* since we are adding at the begining, prev is always NULL */
        new_Node.prev = null; 
          
        /* move the head to point to the new node */
        head = new_Node; 
    } 
      
    /* Driver program to test above written function */
    public static void main(String[] args){ 
        QuickSort_using_Doubly_LinkedList list = new QuickSort_using_Doubly_LinkedList(); 
        Scanner scan = new Scanner(System.in);
        char ch;
        /**  Perform tree operations  **/
        do    
        {
            System.out.println("\nSelect one of the operations::\n");
            System.out.println("1. To insert a new node in the Doubly Linked List.");
            System.out.println("2. To display the nodes of the Doubly Linked List.");
            System.out.println("3. To perform Quicksort on the Doubly Linked List.");
 
            int choice = scan.nextInt();            
            switch (choice)
            {
            case 1 : 
                System.out.println("Enter integer element to insert");
                list.push(scan.nextInt());                     
                break;                          
            case 2 : 
                System.out.println("Doubly Linked List::");
                list.printList(list.head);
                break;                                          
            case 3 : 
                System.out.println("Quicksort done.");
                list.quickSort(list.head);
                break;     
            default : 
                System.out.println("Wrong Entry \n ");
                break;   
            }
            System.out.println("\nDo you want to continue (Type y or n) \n");
            ch = scan.next().charAt(0);                        
        } while (ch == 'Y'|| ch == 'y');
          
    } 
} 

Output

The above Java code gives the following output after execution.

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
265

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
400 

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
133

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
879

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
228

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
609

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
551

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2
Doubly Linked List::
551 609 228 879 133 400 265 
Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1
Enter integer element to insert
23

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2
Doubly Linked List::
23 551 609 228 879 133 400 265 
Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
3
Quicksort done.

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2
Doubly Linked List::
23 133 228 265 400 551 609 879 
Do you want to continue (Type y or n) 

N

In this way, we have written a Java code to perform the quicksort operation on the doubly linked list data structure. There are three functions written for the doubly linked list data structure one is to add a new node in the doubly linked list, the second one is to display all the nodes of the doubly linked list and display the values associated with those nodes, and the last function is to perform the quicksort operation on the doubly linked list data structure.

C Code

Let's write a C code to perform quicksort on a doubly linked list data structure.

// A C program to sort a linked list using Quicksort 
// #include <iostream> 
#include <stdio.h>
#include<stdlib.h>

// using namespace std; 
  
/* a node of the doubly linked list */
struct Node 
{ 
    int data; 
    struct Node *next; 
    struct Node *prev; 
}; 
  
typedef struct Node Node;

/* A utility function to swap two elements */
void swap ( int* a, int* b ) 
{   int t = *a;      *a = *b;       *b = t;   } 
  
// A utility function to find last node of linked list 
struct Node *lastNode(Node *root) 
{ 
    while (root && root->next) 
        root = root->next; 
    return root; 
} 
  
/* Considers the last element as pivot, places the pivot element at its 
   correct position in a sorted array, and places all smaller (smaller than 
   pivot) to the left of the pivot and all greater elements to right of pivot */
Node* partition(Node *l, Node *h) 
{ 
    // set pivot as h element 
    int x  = h->data; 
  
    // similar to i = l-1 for array implementation 
    Node *i = l->prev; 
  
    // Similar to "for (int j = l; j <= h- 1; j++)" 
    for (Node *j = l; j != h; j = j->next) 
    { 
        if (j->data <= x) 
        { 
            // Similar to i++ for array 
            i = (i == NULL)? l : i->next; 
  
            swap(&(i->data), &(j->data)); 
        } 
    } 
    i = (i == NULL)? l : i->next; // Similar to i++ 
    swap(&(i->data), &(h->data)); 
    return i; 
} 
  
/* A recursive implementation of quicksort for linked list */
void _quickSort(struct Node* l, struct Node *h) 
{ 
    if (h != NULL && l != h && l != h->next) 
    { 
        struct Node *p = partition(l, h); 
        _quickSort(l, p->prev); 
        _quickSort(p->next, h); 
    } 
} 
  
// The main function is to sort a linked list. It mainly calls _quickSort() 
void quickSort(struct Node *head) 
{ 
    // Find last node 
    struct Node *h = lastNode(head); 
  
    // Call the recursive QuickSort 
    _quickSort(head, h); 
} 
  
// A utility function to print contents of arr 
void printList(struct Node *head) 
{ 
    while (head) 
    { 
        printf("%d  ",head->data); 
        head = head->next; 
    } 
    printf("\n"); 
} 
  
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(struct Node** head_ref, int new_data) 
{ 
    struct Node* new_node = malloc(sizeof(Node)); //new Node;     /* allocate node */
    new_node->data  = new_data; 
  
    /* since we are adding at the begining, prev is always NULL */
    new_node->prev = NULL; 
  
    /* link the old list off the new node */
    new_node->next = (*head_ref); 
  
    /* change prev of head node to new node */
    if ((*head_ref) !=  NULL)  (*head_ref)->prev = new_node ; 
  
    /* move the head to point to the new node */
    (*head_ref)    = new_node; 
} 
  
/* Driver program to test above function */
int main() 
{ 
    struct Node *a = NULL; 
    int data;
    char ch;
        /*  Perform tree operations  */
        do    
        {
            printf("\nSelect one of the operations::");
            printf("\n1. To insert a new node in the Doubly Linked List.");
            printf("\n2. To display the nodes of the Doubly Linked List.");
            printf("\n3. To perform Quicksort on the Doubly Linked List.\n");

            int choice;
            scanf("%d",&choice);            
            switch (choice)
            {
            case 1 : 
                printf("\nEnter the value of the node to be inserted\n");
                scanf("%d",&data);
                push(&a,data);                     
                break;                          
            case 2 : 
                printf("\nContents of the Doubly Linked List are::\n");
                printList(a);
                break; 
            case 3 : 
                printf("\nQuicksort applied sucessfully on the Doubly Linked List.\n");
                quickSort(a);
                break;
            default : 
                printf("Wrong Entry\n");
                break;   
            }

            printf("\nDo you want to continue (Type y or n)\n");
            scanf(" %c",&ch);                        
        } while (ch == 'Y'|| ch == 'y');
  
    return 0; 
} 

Output

The above C code gives the following output.

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1

Enter the value of the node to be inserted
11

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1

Enter the value of the node to be inserted
65

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1

Enter the value of the node to be inserted
32

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1

Enter the value of the node to be inserted
9 

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2

Contents of the Doubly Linked List are::
9  32  65  11  

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
1

Enter the value of the node to be inserted
522

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2

Contents of the Doubly Linked List are::
522  9  32  65  11  

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
3

Quicksort applied successfully on the Doubly Linked List.

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Doubly Linked List.
2. To display the nodes of the Doubly Linked List.
3. To perform Quicksort on the Doubly Linked List.
2

Contents of the Doubly Linked List are::
9  11  32  65  522  

Do you want to continue (Type y or n)
n

In this way, we have written a C code to perform the quicksort operation on the doubly linked list data structure. There are three functions written for the doubly linked list data structure one is to add a new node in the doubly linked list, the second one is to display all the nodes of the doubly linked list and display the values associated with those nodes, and the third function is to perform the quicksort operation on the doubly linked list data structure.

Next TopicInversion count

← prev next →