【数据结构与算法】——快速排序

数据结构与算法

---

---

---

快速排序

这段代码实现了快速排序算法。快速排序是一种分治算法，它将一个大问题分成两个小问题，然后递归地解决这些小问题。具体来说，这个实现中，我们选择数组中间的元素作为枢轴（pivot），然后将数组分成三个部分：小于枢轴的元素、等于枢轴的元素和大于枢轴的元素。然后，我们递归地对左边和右边的部分进行快速排序，最后将它们和枢轴合并起来。这个实现的时间复杂度为O(nlogn)，其中n是数组的长度。

如果你想了解更多关于快速排序的细节，可以参考以下代码块：

Python版代码：

def quick_sort(arr): # 定义一个快速排序函数，参数为一个列表
    if len(arr) <= 1: # 如果列表长度小于等于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 quick_sort(left) + middle + quick_sort(right) # 递归调用快速排序函数，将左、中、右三个列表合并起来

print(quick_sort([3, 6, 1, 8, 2, 9, 4, 7, 5, 0])) # 调用快速排序函数，输出排序后的列表

# 这一行定义了一个名为quick_sort的函数，它接受一个参数arr。
def quick_sort(arr):
	# 这一行检查输入数组arr的长度是否小于或等于1。如果是，则函数简单地返回输入数组。
    if len(arr) <= 1:
        return arr
    # 如果输入数组有多个元素，则函数将第一个元素设置为枢轴，并初始化两个名为left和right的空数组。
    else:
        pivot = arr[0]
        left = []
        right = []
        # 这个循环从第二个元素开始迭代输入数组，并将每个元素附加到left或right数组中，具体取决于它是小于还是大于枢轴。
        for i in range(1, len(arr)):
            if arr[i] < pivot:
                left.append(arr[i])
            else:
                right.append(arr[i])
         # 最后，函数在left和right数组上递归调用自身，并将排序后的left数组、枢轴和排序后的right数组连接起来返回最终排序后的数组。
        return quick_sort(left) + [pivot] + quick_sort(right)

# 这些行创建一个名为arr的数组，打印它，调用quick_sort函数对其进行排序以获得排序后的数组，然后打印排序后的数组。
arr = [3, 7, 1, 9, 2, 5, 8, 4, 6]
print("Original array:", arr)
sorted_arr = quick_sort(arr)
print("Sorted array:", sorted_arr)

def partition(li,left,right):
    temp = li[left]
    while left < right:
        while left < right and li[right] >= temp: #从右边找比temp小的数
            right -= 1
        li[left] = li[right]   #把右边的值写到左边的空位上
        print(li)
        while left < right and li[left] <= temp: #从右边找比temp小的数
            left += 1
        li[right] = li[left]   #把右边的值写到左边的空位上
        print(li)
        
    li[left] = temp
    return left

def quick_sort(li,left,right):
    if left < right: # 至少两个元素
        mid = partition(li,left,right)
        quick_sort(li,left,mid-1)
        quick_sort(li,mid+1,right)

li = [5,7,4,6,3,1,2,9,8]
print(li)
quick_sort(li,0,len(li)-1)
print(li)

这段代码定义了三个函数：quicksort、partition。quicksort函数以一个数组arr、一个下限left和一个上限right作为输入。它首先检查left是否小于right，如果是，则调用partition函数将数组分区，然后递归调用quicksort函数对两个结果子数组进行排序。

partition函数与quicksort函数接受相同的输入，并在分区后返回枢轴元素的索引。它首先将枢轴元素选择为数组的最后一个元素，然后从left到right-1遍历数组。对于每个小于枢轴的元素，它将其与当前索引i处的元素交换，并将i增加1。最后，它将枢轴元素与索引i+1处的元素交换，并返回i+1。

# 定义快速排序函数
def quicksort(arr, left, right):
    # 如果left < right，说明还需要继续排序
    if (left < right):
        # 找到枢轴点
        pivot = partition(arr, left, right)
        # 对枢轴点左边的子序列进行排序
        quicksort(arr, left, pivot - 1)
        # 对枢轴点右边的子序列进行排序
        quicksort(arr, pivot + 1, right)

# 定义划分函数
def partition(arr, left, right):
    # 选取最后一个元素作为枢轴点
    pivot = arr[right]
    # 定义i指针，指向小于枢轴点的元素
    i = left - 1
    # 遍历整个序列
    for j in range(left, right):
        # 如果当前元素小于枢轴点
        if (arr[j] < pivot):
            # i指针右移
            i += 1
            # 交换i指针和j指针所指向的元素
            arr[i], arr[j] = arr[j], arr[i]
    # 将枢轴点放到正确的位置上
    arr[i + 1], arr[right] = arr[right], arr[i + 1]
    # 返回枢轴点的位置
    return i + 1


# 测试代码
arr = [3, 2, 1, 5, 4,7,6]
quicksort(arr, 0, len(arr) - 1)
print(arr)

C语言版代码：

#include 
void quick_sort(int[], int, int);

int main()
{
    int a[50], n, i;
    printf("Enter the number of elements:"); // 打印提示信息，要求用户输入元素个数
    scanf("%d", &n); // 读取用户输入的元素个数
    printf("\nEnter the elements to be sorted:\n"); // 打印提示信息，要求用户输入待排序的元素
    for(i=0; i<n; i++)
        scanf("%d", &a[i]); // 读取用户输入的待排序元素
    quick_sort(a, 0, n-1); // 调用快速排序算法对元素进行排序
    printf("\nAfter applying quick sort, the sorted elements are: \n"); // 打印提示信息，输出排序后的元素
    for(i=0; i<n; i++)
        printf("%d ", a[i]); // 输出排序后的元素
    printf("\n");
    return 0;
}

void quick_sort(int a[], int left, int right)
{
    int j, i, pivot, temp;
    if(left<right) // 判断是否需要排序
    {
        pivot=left; // 选取第一个元素作为枢轴
        i=left;
        j=right;
        while(i<j) // 循环直到i>=j
        {
            while(a[i]<=a[pivot]&&i<right) // 从左往右找到第一个大于枢轴的元素
                i++;
            while(a[j]>a[pivot]) // 从右往左找到第一个小于等于枢轴的元素
                j--;
            if(i<j) // 如果i
            {
                temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
        temp=a[pivot]; // 将枢轴放到正确的位置上
        a[pivot]=a[j];
        a[j]=temp;
        quick_sort(a, left, j-1); // 对枢轴左边的元素进行排序
        quick_sort(a, j+1, right); // 对枢轴右边的元素进行排序
    }
}

以下是用C语言实现快速排序算法的代码：

#include 
// 定义快速排序函数
void quicksort(int arr[], int left, int right) {
    if (left < right) { // 如果left小于right
        int pivot = arr[right]; // 将数组的最后一个元素作为基准点
        int i = left - 1; // 定义i为low-1
        for (int j = left; j <= right - 1; j++) { // 遍历数组
            if (arr[j] < pivot) { // 如果当前元素小于基准点
                i++; // i加1
                int temp = arr[i]; // 交换i和j的位置
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1]; // 交换i+1和right的位置
        arr[i + 1] = arr[right];
        arr[right] = temp;
        int pi = i + 1; // 定义pi为i+1
        quicksort(arr, left, pi - 1); // 对左边的子数组进行快速排序
        quicksort(arr, pi + 1, right); // 对右边的子数组进行快速排序
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5}; // 定义数组
    int n = sizeof(arr) / sizeof(arr[0]); // 计算数组的长度
    quicksort(arr, 0, n - 1); // 对数组进行快速排序
    printf("Sorted array: "); // 输出排序后的数组
    for (int i = 0; i < n; i++) { // 遍历数组
        printf("%d ", arr[i]); // 输出数组元素
    }
    return 0; // 返回0
}