Can you explain sorting algorithms in different programming languages?

Can you explain sorting algorithms in different programming languages?

Sure! Sorting algorithms like QuickSort, MergeSort, and BubbleSort can be implemented in various languages. Which language are you interested in?

I'd like to see examples in Python and Java.

Great choice! In Python, you can use the built-in sorted() function for a simple sort, or implement QuickSort like this:

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

In Java, a QuickSort implementation looks like this:

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
}

Can you explain the time complexity of these algorithms?

Certainly! The time complexity of QuickSort is O(n log n) on average, but it can degrade to O(n²) in the worst case. MergeSort consistently runs in O(n log n) time. BubbleSort, on the other hand, has a time complexity of O(n²) in the average and worst cases, making it less efficient for large datasets.