我是python的新手,我正在尝试实现quicksort.有人可以帮我完成我的代码吗？
我不知道如何连接三个数组并打印它们.
def sort(array=[12,4,5,6,7,3,1,15]):
less = []
equal = []
greater = []
if len(array) > 1:
pivot = array[0]
for x in array:
if x < pivot:
less.append(x)
if x == pivot:
equal.append(x)
if x > pivot:
greater.append(x)
sort(less)
sort(pivot)
sort(greater)
该Median of medians方法在quicksort类型分区算法中非常流行,以产生相当好的枢轴,从而统一分区数组.其逻辑在维基百科中给出:
所选择的枢轴小于和大于中位数列表中元素的一半,每半个元素大约为n/10个元素(1/2*(n/5)).这些元素中的每一个都是5的中值,使得它少于2个其他元素并且在块之外大于2个其他元素.因此,枢轴在块外部小于3(n/10)个元素,并且大于块外的另外3个(n/10)个元素.因此,所选择的中值将元素分成介于30%/ 70%和70%/ 30%之间的某个位置,这确保了算法的最坏情况线性行为.
有人可以为我清楚地解释一下.我发现很难理解逻辑.
如果可能,我如何改进以下快速排序(性能明智).有什么建议？
void main()
{
quick(a,0,n-1);
}
void quick(int a[],int lower,int upper)
{
int loc;
if(lower<upper)
{
loc=partition(a,lower,upper);
quick(a,lower,loc-1);
quick(a,loc+1,upper);
}
}
/* Return type: int
Parameters passed: Unsorted array and its lower and upper bounds */
int partition(int a[],int lower,int upper)
{
int pivot,i,j,temp;
pivot=a[lower];
i=lower+1;
j=upper;
while(i<j)
{
while((i<upper)&&(a[i]<=pivot))
i++;
while((a[j]>pivot))
j--;
if(i<j)
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}//end while
if(pivot>a[j])
{
temp=a[j];
a[j]=a[lower];
a[lower]=temp;
}
return(j);
}//end partition
如果我们有两个大小为n的数组并且想要对它们的和进行排序,那么天真的方法是将它们的和存储在O(n ^ 2)空间中并在O(n ^ 2 logn)时间内对其进行排序.假设我们被允许具有相同的O(n ^ 2 logn)运行时间,我们如何将总和存储在O(n)的线性空间中？
我想我们并不打算存储所有的金额,因为它们n ^ 2个元素不适合n个空格,而且我们只是按排序顺序打印出所有内容,所以这是否意味着我们必须动态存储项目？有小费吗？
(这是作业问题)
我为一个赋值创建了这个程序,我们需要在它中创建一个Quichesort实现.这是一种混合排序算法,它使用Quicksort直到达到某个递归深度(log2(N),其中N是列表的长度),然后切换到Heapsort,以避免超过最大递归深度.
在测试我的实现时,我发现虽然它通常比常规Quicksort表现更好,但Heapsort一直表现优于两者.任何人都可以解释为什么Heapsort表现更好,在什么情况下Quichesort会比Quicksort 和 Heapsort 更好？
请注意,由于某种原因,赋值将算法称为"Quipsort".
编辑:很显然,"Quichesort"其实等同于 内省排序.
我还注意到我的medianOf3()函数中的逻辑错误导致它为某些输入返回错误的值.这是该功能的改进版本:
def medianOf3(lst):
"""
From a lst of unordered data, find and return the the median value from
the first, middle and last values.
"""
first, last = lst[0], lst[-1]
if len(lst) <= 2:
return min(first, last)
middle = lst[(len(lst) - 1) // 2]
return sorted((first, middle, last))[1]
这会解释算法的性能相对较差吗？
import heapSort # heapSort
import math # log2 (for quicksort depth limit)
def medianOf3(lst):
""" …我需要使用unix排序对一些数据进行排序,但我无法确切地说出正确的语法,数据看起来像
3.9.1 Step 10:
3.9.1 Step 20:
3.8.10 Step 20:
3.10.2 Step 10:
3.8.4 Step 90:
3.8.4 Step 100:
3.8.4 Step 10:
我想首先使用主要数字,然后是步骤编号对其进行排序,例如,上面排序的数据看起来像.
3.8.4 Step 10:
3.8.4 Step 90:
3.8.4 Step 100:
3.8.10 Step 20:
3.9.1 Step 10:
3.9.1 Step 20:
3.10.2 Step 10:
我找到了按此网站上的第一个数字排序的方法:
sort -t. -k 1,1n -k 2,2n -k 3,3n
但我现在正在努力排序第3列步骤编号,而不会打扰第一类
我是一名计算机科学专业的学生（刚刚开始），我正在努力从伪代码编写快速排序的随机枢轴版本。我已经编写并测试了它，但一切都很完美......
分区部分看起来有点太复杂了，感觉漏掉了什么或者想太多了。我不明白这是否可以，或者我是否犯了一些可以避免的错误。
长话短说：它确实有效，但如何做得更好呢？
预先感谢您的所有帮助
void partition(int a[],int start,int end)
{
srand (time(NULL));
int pivotpos = 3; //start + rand() % (end-start);
int i = start; // index 1
int j = end; // index 2
int flag = 1;
int pivot = a[pivotpos]; // sets the pivot's value
while(i<j && flag) // main loop
{
flag = 0;
while (a[i]<pivot)
{
i++;
}
while (a[j]>pivot)
{
j--;
}
if(a[i]>a[j]) // swap && sets new pivot, and restores the flag
{ …这是我的红宝石代码：
books = ["Charlie and the Chocolate Factory", "War and Peace", "Utopia", "A Brief History of Time", "A Wrinkle in Time"]
books.sort! {
|firstBook, secondBook|
boolean_value = firstBook <=> secondBook
print "first book is = '#{firstBook}'"
print " , second book is = '#{secondBook}'"
puts " and there compare result is #{boolean_value}"
}
问题：
in 'sort!': comparison of String with String failed (ArgumentError)我正在学习快速排序.我知道当分量值执行不平衡分区时,快速排序执行得很糟糕,因此第一个元素或最后一个元素不是一个好选择,因为如果列表几乎排序,则分区将是不平衡的.
当我搜索我发现2个选项:
一种是在低(最低指数)和向上(最高指数)之间随机选择一个支点.这似乎是一个安全的选择,但随机数生成器是耗时的.
第二个是取所有元素的中位数.此选项很昂贵,因此第一个,最后一个和中间元素的中位数可用作枢轴元素.
哪种方法被证明是最有效的快速排序？..有没有其他方法可用于选择枢轴元素？
请问功能qsort()在stdlib.h实际使用快速排序算法,顾名思义？