我试图用Java编写一个快速排序算法,当我尝试运行它时,我遇到了一些问题。
public static <T extends ICompare<T>> void quicksort(T[] a, int start, int end) {
start = 0;
end = a.length - 1;
int i = start;
int k = end;
if (end - start >= 1) {
T pivot = a[start];
while (k > i) {
我正在尝试在ArrayList上实现QuickSort算法。然而,我得到了一个
Exception in thread "main" java.lang.StackOverflowError
at sorting.QuickSort.quickSort(QuickSort.java:25)
at sorting.QuickSort.quickSort(QuickSort.java:36)
at sorting.QuickSort.quickSort(QuickSort.java:36)
at sorting.QuickSort.quickSort
第一个问题!因此,我正在尝试学习Python (来自于两个学期的Java使用),我遇到了一个TypeError,我相信这是因为它有一个函数,而这个函数应该有一个列表。下面是我的代码:
t = [3,5,2,4,1]
def quicksort(lst):
if len(lst) == 0:
return []
pivot = [lst[0]]
left = [x for x in lst if x < pivot[0]]
right = [x for x in lst if x > pivot[0]]
ans = quick
我是编程新手,在尝试编写快速排序程序时,我似乎找不出错误。我已经完成了大部分的实现,除了一些我似乎找不到的错误。下面是我当前的代码:
public class Quicksort {
public static void main(String[] args) {
Integer[] numbers = new Integer[20];
for (int i = 0; i < numbers.length; i++) {
numbers[i] = (int) (Math.random() * 100);
}
我正在尝试QuickSort的一个实现,但是得到了一个
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
at com.JavaReference.QuickSort.swap(QuickSort.java:50)
at com.JavaReference.QuickSort.randPartition(QuickSort.java:20)
at com.JavaReference.QuickSort.randSort(QuickSort.java:12)
at com.JavaRe
我使用快速排序算法对数组进行排序,这是我在QuickSort.java中的代码:
public class QuickSort {
public ArrayList<Integer> quickSort(ArrayList<Integer> data , int low , int high){
ArrayList<Integer> sortedData = new ArrayList<Integer>();
if(low< high) {
int pivotIndex = low; // Assume
我正在努力实现快速排序。看起来很简单,实现一个枢轴函数,以便将较小的元素和较大的元素聚集在两个单独的列表中。递归地这样做,直到列表足够小,可以在恒定的时间内排序。
def pivot(a, pivot_index):
# I guess you can keep two indexes one greater and one lesser and swap.
i, j = 0, len(a)-2
p = a[pivot_index]
a[pivot_index] = a[len(a)-1]
a[len(a)-1] = p
while(i<
我正在测试我编写的快速代码,但我不知道为什么
错误:
Exception in thread "main" java.lang.StackOverflowError
at java.util.ArrayList$Itr.<init>(ArrayList.java:820)
at java.util.ArrayList.iterator(ArrayList.java:814)
at practice.Quicksort.quicksort(Quicksort.java:15)
at practice.Quicksort.quicksor
我试图做一个快速排序,但它总是显示错误的ArrayIndexOutOfBoundsException。
public class Quicksort
{
void sort(int[] arr)
{
_quicksort(arr, 0, arr.length - 1);
}
private void _quicksort(int[] arr, int left, int right)
{
int pivot = (left + right)/2;
int l = left;
int r =
我正在尝试实现快速排序算法,但我一直将列表索引超出范围。
在快速排序(数组,左,Pi vot 1)范围内到底是什么?
def partition(array,left,right):
#If pivot is not on leftmost, swap to make it leftmost
Pivot = array[0]
i = left+1
for j in range(i,right):
if array[j] < Pivot:
#Swap array[j] and array[i]
对于QuickSort的CLRS算法,
我在跟踪输入A= 2,1,3的所有调用时遇到了困难。
QuickSort(A,p,r)
if p < r
q = Partition(A,p,r)
QuickSort(A,p,q-1)
QuickSort(A,q+1,r)
Partition(A,p,r)
x = A[r]
i = p - 1
for j = p to r - 1
if A[j] <= x
i = i + 1
swap (A[i], A[j])
swap(A[i+1], A[r])
retu
我在下面用Python编写了用于快速排序的代码,但获得了RecursionError:在中超过了最大递归深度。当运行另一个相同逻辑的代码时,它运行得很好。
下面是我写的代码-:
def partition(Arr,start,end):
pivot=Arr[end]
pindex=start
for i in range(start,end):
if Arr[i] <= pivot:
Arr[i],Arr[pindex] = Arr[pin
我在main中创建了一个作为普通函数的快速排序算法,然后尝试将其转移到一个类中(根据我的讲师的要求)。然而,我现在得到一个分段错误,但我不知道它是在哪里发生的。下面的源代码;谢谢。
main.cpp
#include "MergeSort.h"
#include "QuickSort.h"
#include <iostream>
using namespace std;
const int SIZE = 10;
int main() {
cout << "This is compiling.\n";
i
我用C语言实现了Shell排序,它只比Bubble排序快3倍。以下是我的排序持续时间(秒):
For list of 100 integers:
BubbleSort: 0.000333
ShakeSort: 0.000282
QuickSort: 0.000048
QuickSort_Iter: 0.000063
InsertionSort: 0.000188
ShellSort: 0.000150
For list of 1000 integers:
BubbleSort: 0.028191
ShakeSort: 0.019354
QuickSort: 0.000435
QuickSor
我有个问题。我正在学习java,这个示例代码不起作用,它说:
$javac Quicksort.java 2>&1
Quicksort.java:16: error: constructor Quicksort in class Quicksort cannot be applied to given types;
Quicksort qc = new Quicksort(values);
^
required: no arguments
found: int[]
reason: actual and formal argumen
我一直试图用java编写一个多线程的快速排序程序。使用ThreadPool、CountDownLatch等进行在线测试的样品很多。
但是,我只想使用count来统计创建的线程数量。
程序背后的逻辑是:
1. The main thread calls the parallel quicksort method
2. The method partitions the array and check for the number of current threads
3. Spawn new threads for next step using the same parallel met
我已经实现了一个有效的quickSort算法,使用数组中的第一个元素作为枢轴,如下所示:
public int[] quickSort( int[] a, int start, int end){
int l = start;
int r = end;
int pivotIndex = start; //<---- first element in the array as pivot!
// must be at least two elements
if ( end - start >= 1){
// set p
我试图使用Cython将c函数包装为一个数组参数(quick_sort()),这样我就可以向它传递一个numpy数组。我已经搜索了文档,所以和网络寻找一个有用的,最小的例子,但没有找到它。我尝试过几种可能性,但没有取得任何进展,所以请帮助我找出答案。这是我的档案:
quicksort.c
#include <stdio.h>
void quick_sort (int* a, int n) {
int i, j, p, t;
if (n < 2)
return;
p = a[n / 2];
for (i = 0, j = n -
我阅读了并找到了一个Quicksort 的实现,我仍然不清楚为什么Quicksort需要额外的O(log )空间。
我明白什么是呼叫堆栈。我将上面提到的实现应用于一个随机数数组,并看到了n - 1调用quickSort。
public static void main(String[] args) {
Random random = new Random();
int num = 8;
int[] array = new int[num];
for (int i = 0; i < num; i++) {
我正在学习快速排序算法。我不知道我哪里出了问题。我相信我已经正确地实现了这个算法,因为有些随机值是排序的,而另一些则不是。在尝试调试此问题时,我将数组的大小更改为3,而不是最初的20。
public class Quicksort {
public static void main(String[] args) {
// Generate a random array of integers to sort
// Integer[] numbers = new Integer[20];
// testing int, above is o
我遵循以下伪码:
function quicksort(array)
if length(array) > 1
pivot := select any element of array
left := first index of array
right := last index of array
while left ≤ right
while array[left] < pivot
left := left + 1
while
我现在正在用java编写一个快速排序程序,遇到了一个错误。终端机说
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 101 out of bounds for length 19
at QuickSort.swap(qs.java:16)
at QuickSort.partition(qs.java:23)
at QuickSort.quickSort(qs.java:9)
at QuickSort.quickSort(qs.java:5)
各位!
我在Java中的quicksort实现中遇到了一些堆栈溢出问题,对于每一次快速排序的递归调用,都使用随机枢轴元素,如下面的代码所示。我的问题是我在三点钟就有堆叠溢出(!)我代码中的位置:
import java.util.Random;
/**
* Write a description of class QuickSort1 here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class QuickSort1 implements IntSorter
{
我想检查一下这是否是一个正确的QuickSort实现,它似乎是在做的工作,但我是不是遗漏了什么?
public class QuickSort implements Sorter {
public void sort(Comparable[] items) {
QuickSort(items, 0, items.length - 1);
}
static void QuickSort(Comparable[] items, int a, int b) {
int lo = a;
int hi = b;
if (lo >= hi) {
r
我正在尝试创建一个递归函数来将列表从低到高进行排序。下面的代码不工作
less = []
greater = []
def quicksort(array):
if len(array)<2:
return array
else:
pivot = array[0]
for i in array[1:]:
if i <= pivot:
less.append(i)
else:
greater.append(i)
我试图为我的程序运行一个JUnit测试,但是我收到的错误消息如下
*incompatible types
required: int[];
found: int *
下面是显示错误的代码
myQSArray = QS.quickSort(sortedArray2,0, sortedArray2.length - 1);
下面是我对quickSort method的调用
public static int quickSort( int A[], int p, int r){
int q;
if (p<r)
{
q = partition(A,p,