快排 随机分割

计算机算法设计与分析第四版[王]

#include<iostream>
#include <stdlib.h> 
using namespace std;
inline void swap(int &a, int &b)
{
    int c = a;
    a = b;
    b = c;
}
//随机分割
int Random(int a, int b)//随机在a--b选择一个整数
{
    return a + rand() % (b - a + 1);
}
template<class type>
int RandomizedPartition(type a[], int p, int r)//随机分割
{
    int i = Random(p, r);//在p--r中随机选择一个数
    swap(a[i], a[p]);
    return Partition(a, p, r);
}
template<class type>
int Partition(type a[], int p, int r)//以随机选的那个数作为分割起点,p此时是之前随机选的a[i]的位置;
{
    int i = p, j = r + 1;
    type x = a[p];
    while (true)
    {
        while (a[++i] < x&&i < r);   //找到比标杆大的元素
        while (a[--j] > x);         // 找到比标杆小的元素
        if (i >= j) break;
        swap(a[i], a[j]);
    }
    a[p] = a[j];
    a[j] = x;
    return j;//返回结束后分割点所在的位置
}

template<class type>
void RandomizedQuickSort(type a[], int p, int r)
{
    if (p < r)
    {
        int q = RandomizedPartition(a, p, r);
        RandomizedQuickSort(a, p, q - 1);//左半端排序
        RandomizedQuickSort(a, q + 1, r);//右半段排序
    }
}
int main()
{
    int a[] = { 5,1,66,44,87,32,12,66,99,45,32,156,456 };
    RandomizedQuickSort(a, 0, 12);
    for (int i = 0;i < 12;i++)
    {
        cout << a[i] << endl;
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: ,现在是2020年6月9日。 我可以提供一种快速排序算法,它的时间复杂度为O(nlog n),其中n是数组的大小。它的基本思想是:选择一个基准元素,将数组分割成两个子数组,其中一个子数组中的元素都小于基准元素,另一个子数组中的元素都大于基准元素,然后递归地对子数组进行排序。 ### 回答2: 快速排序(Quick Sort)是一种常用的排序算法,其时间复杂度为O(nlogn)。下面是一个简单的快速排序算法的实现: 1. 首先,从数组中选择一个元素作为基准(pivot)。 2. 创建两个指针,一个指向数组的起始位置(low),另一个指向数组的结束位置(high)。 3. 将基准元素放在合适的位置上,使得其左边的元素都比它小,右边的元素都比它大。可以通过以下过程实现: - 从high指针开始往前遍历,如果遇到一个比基准小的元素,则将其放在low指针所指的位置,并将low指针向后移动一位; - 从low指针开始往后遍历,如果遇到一个比基准大的元素,则将其放在high指针所指的位置,并将high指针向前移动一位; - 重复上述过程,直到low和high指针相遇。 4. 根据low指针的位置,将数组划分为两个子数组,分别对两个子数组递归地进行快速排序。 下面是使用Python实现的快速排序算法代码: ```python def quick_sort(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 quick_sort(left) + middle + quick_sort(right) ``` 这段代码使用了列表推导式来将数组划分为小于、等于和大于基准元素的三部分。然后,通过递归地对左右两个子数组进行快速排序,最终合并排序后的子数组。 快速排序算法具有较小的时间复杂度,适用于对大规模数据进行排序。但在最坏情况下,即已排序的数组中,快速排序算法的时间复杂度可能为O(n^2),因此在实际应用中需要进行优化。 ### 回答3: 快速排序是一种常用的排序算法,它的时间复杂度可以达到O(nlogn)。下面是一个简单的快速排序算法实现: 快速排序的基本思路是通过一趟排序将待排序的数据分割成独立的两部分:小于基准值的元素和大于基准值的元素。然后再分别对这两部分进行排序。具体步骤如下: 1. 选择一个基准值,可以是数组的第一个元素,也可以是随机选择的元素。 2. 设定两个指针,左指针指向数组的第一个元素,右指针指向数组的最后一个元素。 3. 左指针向右移动,直到找到大于等于基准值的元素停止。 4. 右指针向左移动,直到找到小于等于基准值的元素停止。 5. 交换左指针和右指针指向的元素。 6. 重复步骤3~5,直到左指针大于等于右指针。 7. 将基准值和右指针指向的元素交换。 8. 对基准值左边的子数组和右边的子数组分别进行快速排序。 以下是一个示例的快速排序实现: ``` def quicksort(arr, low, high): if low < high: pivot_index = partition(arr, low, high) quicksort(arr, low, pivot_index - 1) quicksort(arr, pivot_index + 1, high) def partition(arr, low, high): pivot = arr[low] left = low + 1 right = high done = False while not done: while left <= right and arr[left] <= pivot: left = left + 1 while arr[right] >= pivot and right >= left: right = right - 1 if right < left: done= True else: arr[left], arr[right] = arr[right], arr[left] arr[low], arr[right] = arr[right], arr[low] return right arr = [5, 8, 2, 6, 1, 9, 3, 7] quicksort(arr, 0, len(arr) - 1) print(arr) ``` 该实现中,使用递归的方式对左右两个子数组进行快速排序,实现了快速排序算法。时间复杂度主要取决于划分的次数,即递归调用quick_sort的次数,该次数与数组的大小以对数关系增长,因此该实现的时间复杂度为O(nlogn)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值