Python Tutorial

The comparison-based sorting algorithm, Quick Sort, uses the divide-and-conquer strategy. It divides the remaining members into 2 sub-arrays (or sub-lists) determined by whether they are less than or greater than the element that serves as the pivot, which is chosen as the "pivot" element from the array (or, in our instance, the doubly linked list). The sub-arrays are next sorted recursively. Due to the linked layout of the data, there are a few special considerations when using Quick Sort to sort a doubly linked list. We rely on node manipulation rather than straight indexing like in arrays for traversal and reordering.

Primary steps for Quick Sort on a doubly linked list are as follows:

Partitioning: Choosing a pivot element within the linked list constitutes partitioning. The nodes are then rearranged so that all nodes with values below the pivot are placed before it, and all nodes with values above the pivot are placed after it. The nodes' next and prior pointers are modified during this partitioning process.
Recursion: Recursive application of Quick Sort on the sub-lists before and after the pivot node is in the proper position.
Combining: We finally combine the sorted sub-lists to create a completely sorted doubly linked list.

Code implementation

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None
def partition(start, end):
    pivot = end
    pivot_value = pivot.data
    current = start
    while current != pivot:
 if current.data <= pivot_value:
            current = current.next
        else:
            current.data, pivot.data = pivot.data, current.data
        start = current
    return start
def quicksort(start, end):
    if start is None or start == end or start == end.next:
        return
    pivot = partition(start, end)
    if pivot != start:
        quicksort(start, pivot.prev)
    if pivot != end:
        quicksort(pivot.next, end)
def print_list(head):
    current = head
    while current:
        print(current.data, end=" <-> ")
        current = current.next
    print("None")
def append_node(head, data):
    new_node = Node(data)
    if head is None:
        return new_node
    current = head
    while current.next:
        current = current.next
    current.next = new_node
    new_node.prev = current
    return head
if __name__ == "__main__":
    head = None
    data_list = [3, 6, 1, 9, 4, 2]  
    for data in data_list:
        head = append_node(head, data)
    print("Original List:")
    print_list(head)
    quicksort(head, None)
    print("\nSorted List:")
    print_list(head)

Output:

Original List:
3 <-> 6 <-> 1 <-> 9 <-> 4 <-> 2 <-> None
Sorted List:
1 <-> 2 <-> 3 <-> 4 <-> 6 <-> 9 <-> None

Time Complexity

Best Case: When the pivot used consistently divides the list into about equal sections, Quicksort's best-case time complexity happens. It becomes O(n log n) time complicated in this case.
Average Case: Quicksort typically displays O(n log n) time complexity when the pivot selection is fairly random.
Worst situation: In the worst situation, Quicksort may decrease to O(n2) time complexity when the pivot selection continually produces unbalanced divisions. However, this can be reduced by employing randomized pivot selection or a good pivot selection approach.

Advantages of Quicksort:

Efficiency: Quicksort is renowned for being efficient and frequently outperforms other sorting algorithms in huge datasets.
In-Place Sorting: Quicksort is an in-place sorting algorithm; therefore, it doesn't require extra memory to store elements while sorting temporarily. This implies that it mostly modifies the pointers of the existing nodes in the doubly linked list implementation, hence minimizing memory overhead.
Good Average Case Performance: Quicksort has a good average-case performance and an O(n log n) time complexity, making it ideal for various applications.

Conclusion

Python's Quicksort implementation on doubly linked lists offers a useful way to sort data inside this adaptable data structure. The doubly linked list variation of Quicksort praised for its effectiveness, especially for huge datasets, builds on its advantages while resolving the particular difficulties linked structures present. The capabilities of this implementation's in-place sorting is its main benefit. Quicksort minimizes memory overhead, making it ideal for applications with strict memory limits, in contrast to other sorting algorithms. The technique rearranges elements without needing to allocate more memory by modifying the next & previous pointers of the nodes.

Despite Quicksort's excellent average-case performance, it's important to recognize the possibility of worst-case circumstances when its time complexity drops to O(n2). This risk can be reduced by giving pivot selection careful thought and, if practical, using randomization approaches. Quicksort continues to be a flexible and effective sorting algorithm that may be applied in a doubly linked list situation. It is a helpful tool for programmers because of its effectiveness, memory-friendliness, and versatility to different datasets, with the proviso that pivot selection algorithms should be customized for particular use cases to guarantee consistently great performance.

Next TopicRandom Acyclic Maze Generator with given Entry and Exit point using Python

← prev next →