数据结构与算法
快速排序
这段代码实现了快速排序算法。快速排序是一种分治算法，它将一个大问题分成两个小问题，然后递归地解决这些小问题。具体来说，这个实现中，我们选择数组中间的元素作为枢轴（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 <stdio.h>
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<j，则交换a[i]和a[j]
{
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 <stdio.h>
// 定义快速排序函数
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
}
