我试图实现QuickSort，但得到的是垃圾数组元素作为输出
快速排序（QuickSort）是一种常用的排序算法，它基于分治的思想，通过将数组分成较小的子数组来逐步排序。然而，当你得到垃圾数组元素作为输出时，可能是因为在实现快速排序算法时出现了一些错误。
以下是一些可能导致问题的原因和解决方法：
- 错误的分区策略：快速排序的核心是选择一个基准元素，并将数组分成两个子数组，一个小于基准元素，一个大于基准元素。如果分区策略有误，可能导致数组没有正确地分割。可以尝试使用经典的Lomuto或Hoare分区方案，确保正确地分割数组。
- 未正确处理边界条件：在实现快速排序时，需要考虑边界条件，如空数组或只有一个元素的数组。如果没有正确处理这些情况，可能导致错误的输出。在递归调用时，需要确保子数组的长度大于1。
- 未正确选择基准元素：选择一个合适的基准元素对快速排序的性能至关重要。如果选择的基准元素不合适，可能导致排序效率低下甚至出现栈溢出等问题。可以尝试选择数组的中间元素或随机选择一个元素作为基准。
- 未正确交换元素：在分区过程中，需要正确地交换元素以实现数组的分割。如果交换操作有误，可能导致错误的输出。确保在交换元素时，使用正确的索引和临时变量。
- 未正确处理递归调用：快速排序是一种递归算法，需要正确处理递归调用以确保排序的正确性。在递归调用时，需要传递正确的子数组范围。
综上所述，要实现正确的快速排序算法，需要确保正确的分区策略、处理边界条件、选择合适的基准元素、正确交换元素以及正确处理递归调用。如果你遇到问题，可以逐步检查这些方面并进行调试。
关于腾讯云相关产品和产品介绍链接地址，可以参考腾讯云官方文档或咨询腾讯云的技术支持团队，以获取更详细的信息。
相关·内容
1回答
在Python中实现快速排序
、、、、
我正在努力实现快速排序。看起来很简单，实现一个枢轴函数，以便将较小的元素和较大的元素聚集在两个单独的列表中。递归地这样做，直到列表足够小，可以在恒定的时间内排序。
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<
浏览 1提问于2017-12-29得票数 2
1回答
构建快速排序和合并排序
、、、、
我已经构建了与快速排序和合并排序相关的函数。我没有得到任何错误，但我仍然没有得到所需的输出。 #include <iostream>
using namespace std;
void swap(int *a, int *b);
void printarray(int array[], int size);
int partition(int array[], int low, int high, int select);
void quicksort(int array[], int low, int high, int select);
void merge(in
浏览 25提问于2021-10-08得票数 1
当我试图在JS中实现快速排序时，有什么问题呢？我得到一个调用堆栈大小超过错误。
function quicksort(arr) {
if (arr.length <= 1)
return arr;
let pivot = Math.floor(arr.length / 2);
const left = [], right = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
}
else {
浏览 4提问于2020-02-23得票数 0
回答已采纳
我试图通过将最后一个元素作为枢轴来实现quickSort。但我无法产生有效的输出。
另外，需要做哪些改变才能使其随机化？我正在用Java编写代码。
public class QuickSortDemo {
public static void quicksort(int A[], int temp[], int left, int right) {
int q, i;
//why u need to check this base case always
if (left < right) {
q = p
浏览 2提问于2015-03-28得票数 0
回答已采纳
3回答
正如标题所述，我一直试图打印动态分配给指针的数组的元素。在添加了一些元素之后，我尝试让它打印出数组的元素，但是我得到了非常奇怪的字符，它们甚至不是ints。这是一些代码。
//QS.h
class QS: public QSInterface { //where the pointer is declared
private:
int* quickSort;
//QS.cpp
bool QS::createArray(int capacity) { //where the array is created
if (quickSort != NULL) {
//delete []
浏览 5提问于2017-04-17得票数 0
回答已采纳
2回答
我刚刚实现了书中的QuickSort算法，得到了奇怪的输出。它可以工作，但它是按降序而不是升序排序的。例如: 1，5，2，10，6，9，8，3，7，4排序为10，9，8，7，6，5，4，3，2，1似乎在我的代码中找不到源代码：
private void quicksort(int[] A, int p, int r) {
if (p < r) {
int q = partition(A, p, r);
quicksort(A, p, q);
quicksort(A, q + 1, r);
}
}
private int p
浏览 0提问于2012-06-26得票数 2
回答已采纳
我试图为快速排序选择一个随机索引，但由于某种原因，数组没有排序。实际上，该算法返回一个不同的数组(例如。有时输出输入2,1,4和1,1,4 )。任何帮助都将不胜感激。如果我总是选择数组的第一个元素作为支点，而不是选择一个随机索引，这个算法就能工作。
def quicksort(array):
if len(array) < 2:
return array
else:
random_pivot_index = randint(0, len(array) - 1)
pivot = array[random_pivot_index]
less = [i
浏览 6提问于2021-12-17得票数 1
1回答
我是一个初学者，试图编写一组快速排序函数，并得到一个分段错误(核心抛出)。
我的递归快速排序函数应该调用helper快速排序函数，该函数
调用分区函数来完成大部分实际工作，
调用自己递归处理子数组：
我已经看了好几个小时了，并试图找出导致这种情况的错误。任何帮助都会令人难以置信地感激。提前感谢你成为一个很棒的人。
x86 AT&T语法
.text
.globl quicksort
quicksort:
#subroutine prologue
pushl %ebp #store stack frame of calling func
浏览 0提问于2016-04-29得票数 0
2回答
作为对编程相当陌生的人，我正在尝试用Python实现快速排序。然而，我试图以一种方式来实现它，这似乎并不是最常见的方法。我正在使用CS50：在这个视频中解释的技术
这个版本的算法在数组的末尾选择一个支点，在开始处放置一个“墙”，然后开始迭代列表。当它发现一个小于枢轴的项目时，它会将该项目与墙右侧的项目互换，并将墙壁移动到右侧的一个位置。当将所有项目与枢轴进行比较时，它将枢轴放置在墙上，而墙壁则向右移动一个位置。这种情况一直持续到数组的末尾。
到目前为止，我想出了如下结论：
def quicksort(alist):
quicksort_helper(alist)
print a
浏览 2提问于2016-03-08得票数 1
回答已采纳
有人能指导我实现QuickSort吗？当我选择pivot作为数组中的最后一个元素时，我试图可视化我的快速排序实现的错误之处。 下面是我的代码： public void quickSort(int[] input, int left, int right) {
if(left < right) {
//int pivot = input[(left + right) / 2]; // works fine with this
//int pivot = input[left]; // wo
浏览 13提问于2020-09-14得票数 1
6回答
我读过关于快速排序算法的文章，但我不明白如何选择pivot元素。从教程中我得到了quciksort的示例代码：
public void quicksort(int[] A, int left, int right) {
int pivot = A[left + (right - left) / 2];
int i = left;
int j = right;
while (i <= j) {
while (A[i] < pivot) {
i++;
}
while (A[j] &g
浏览 0提问于2013-07-03得票数 5
回答已采纳
1回答
我试图做一个快速排序，但它总是显示错误的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 =
浏览 1提问于2018-11-29得票数 1
回答已采纳
我遵循以下伪码：
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
浏览 2提问于2018-11-22得票数 0
回答已采纳
我试图在上用C++编写第一个算法。这就是我适应这门语言时得到的结果：
void quicksort (vector<int>& numbers) {
int leftSize = numbers.size() / 3
, rightSize = numbers.size() - leftSize;
vector<int>::iterator pivot = numbers.end() - rightSize; //Choose one third of the way through as the pivot.
v
浏览 4提问于2014-02-12得票数 0
回答已采纳
我正在尝试在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
浏览 1提问于2013-10-27得票数 0
6回答
我正在尝试用Java实现QuickSort算法程序，但是我得到了错误的答案。
public class QuickSort {
public static void main(String[] args){
int arr[]={12,34,22,64,34,33,23,64,33};
int i=0;
int j=arr.length;
while(i<j){
i=quickSort(arr,i,i+1,j-1);
}
for(i=0;i<ar
浏览 1提问于2010-02-05得票数 6
回答已采纳
1回答
我有一个项目要使用array500000算法对quickSort进行排序，我已经实现了如下quickSort：
public void sort (int[] array){
sort(array, 0, array.length - 1);
}
private void sort (int[] array, int start, int end){
if (start >= end) {
return;
}
var boundary = partition(array, start, e
浏览 5提问于2020-11-04得票数 0
1回答
目前，我正在学习C，并选择实现快速排序作为练习。
我的代码是正确的排序，但之后，我看了一些教程关于快速排序在线。他们用不同的方式实现它。
我不知道，是我误解了快速排序，还是简单地以不同的方式实现了它。
我是如何理解快速排序的：
选择枢轴
根据其大小(比枢轴大/小)
重复直到数组被排序
我使用中间元素作为枢轴，以避免标准的最坏情况。
我的代码：
#include <stdio.h>
#include <math.h>
void quicksort(unsigned int* array, unsigned int length)
{
if (length &l
浏览 0提问于2020-04-20得票数 1
回答已采纳
2回答
我想做一些简单的练习，所以我决定使用并将其更改为使用numpy。
这是原文：
def quicksort(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 quicksort(left) + mi
浏览 1提问于2018-01-23得票数 1
回答已采纳
1回答
索引16长度超出界限16
、、、
我试图使用quickSort对x元素数组进行排序，但是我得到了一个错误“索引16超出了长度16的界限”，请帮助。
public class quickSort {
static int partition(int []arr, int lo, int hi){
int pivot=arr[lo];
while(lo<hi){
while(pivot<arr[hi] && lo<hi)
hi = hi - 1;
if (hi != lo
浏览 1提问于2022-02-27得票数 -1
回答已采纳
2回答
使用指针的快速排序算法？
、、、
试图创建一个使用指针的快速排序算法，但没有太多的运气。我的代码可以编译，但不能工作，我对如何纠正这个问题感到困惑。任何帮助都将不胜感激。
int* partition(int* start, int* stop) {
int* pivot = stop - 1; // you can randomly pick one as the pivot
int* i = start;
int* j = stop - 1;
for (;;) {
while (i < pivot && i < stop) ++i; // skip
浏览 0提问于2016-10-18得票数 0
我正在跟踪javascript中有关算法的一些视频，发现指导员使用如下代码实现了一个快速排序：
function quickSort(arr){
if(arr.length <= 1) return arr
const pivot = arr[arr.length - 1]
let left = []
let right = []
for(let i = 0; i < arr.length-1; i++){
if (arr[i] < pivot) {
left.push(arr[i])
} else {
right.
浏览 0提问于2017-05-16得票数 0
回答已采纳
1回答
我正在尝试使用python实现快速排序算法我认为我已经正确地完成了这些步骤，但似乎我的代码有问题，每次我运行代码它都不能工作，请你能帮我找出我的代码的问题。
def quicksort(alist,first,last):
if first < last:
split = partition(alist,first,last)
quicksort(alist,first,split-1)
quicksort(alist,split+1,last)
def partition(arr,first,last):
piv
浏览 24提问于2018-05-31得票数 2
回答已采纳
1回答
我有这个快速排序实现来对字符进行排序。
int main(){
char val[] = "dcbeaaae";
QuickSort(val, 0, length);
for(int i=0;i<length;i++) //Sorted print
cout<<val[i];
return 0
}
void QuickSort(char values[], int first, int last)
{
if(first<last)
{
int splitPoint;
Sp
浏览 0提问于2012-06-09得票数 2
回答已采纳
3回答
我试图实现QuickSort算法，由ThomasH.Cormen，CharlesE.Leiserson，RonaldL.Ri背心，Clifford算法导论，第三版- 2009 *第7.1节
在JavaScript中。
下面是我的实现：
function swap(arr, i, j) {
const temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function partition(arr, left = 0, right = arr.length - 1) {
let pivot = arr[right];
浏览 1提问于2019-06-22得票数 1
回答已采纳
我已经尝试调试了几个小时的代码，但没有取得任何进展。我很喜欢有人能帮我，我刚开始学习算法
def quicksort(arr):
start = 0
end = len(arr) - 1
quick_sort(arr, start, end)
def quick_sort(arr, start, end):
if start < end:
pindex = partition(arr, start, end)
quick_sort(arr, start, pindex)
quick_sort(arr, p
浏览 0提问于2018-08-04得票数 0
回答已采纳
1回答
降低快速排序法的复杂度
、、、、
嘿，伙计们，我有一个问题，我正在试着降低这段代码的复杂性(在底部)。我的想法是删除while循环中的If子句，但我有点做不到。我在这里尝试做的是比较SortArray的两个元素，并使用快速排序算法对它们进行排序。目标是使算法尽可能简单。较小和较大的索引遍历数组，并在元素大于轴心时切换。更大的是在中间的末端，以便与枢轴进行切换。
if (records.getElementAt(smaller).compareTo(Pivot) > 0 ) {
swap(records, smaller, bigger);
bigger--;
}
浏览 5提问于2018-05-06得票数 0
我正在学习快速排序算法，但是由于某些原因，这个python实现的输出只是部分排序，对于较大的输入，我得到了“达到的最大递归深度”。在过去的几天里，我一直在努力解决这个问题，我知道这可能是非常愚蠢的事情，但我似乎无法弄清楚，所以我将非常感谢任何帮助。
def ChoosePivot(list):
return list[0]
def Partition(A,left,right):
p = ChoosePivot(A)
i = left + 1
for j in range(left + 1,right + 1): #upto right + 1 beca
浏览 0提问于2012-04-06得票数 0
回答已采纳
2回答
我实现了以下代码，但它似乎不适用于我的数组具有重复值的情况。
private int partition(Integer[] arr,int left, int right)
{
int i = left;
int j = right;
int pivot = arr[left];
while(true)
{
while(arr[i] <pivot) i++;
while(arr[j] > pivot) j--;
if(i < j)
{
p
浏览 0提问于2016-02-14得票数 1
使用Java (如果重要的话)
我正在一个接一个地运行MergeSort和QuickSort，比较两者的运行时间，在我的计算机上对10,000,000个值进行排序时，我发现运行MergeSort时的运行时间是QuickSort
MergeSort = 1.6s (大约)
QuickSort = 0.3s (大约)
首先运行快速排序，然后在相同输入大小为10,000,000的情况下运行MergeSort
MergeSort = 0.6s
QuickSort = 1.2s
我想这可能与内存分配有关，但我不知道你会怎么解释
-编辑-在运行这两个例程之前，我正在创建一个包含10,000,000个随机值
浏览 2提问于2013-08-25得票数 1
回答已采纳
try {
for (i = 0; i < data.length; i++) {
working[i] = data[i];
}
FileWriter fw3 = new FileWriter("quicksort.dat");
long startTime3 = System.nanoTime();
quickSort(working,0, working.length - 1);
l
浏览 42提问于2020-11-01得票数 1
回答已采纳
3回答
我试图使用快速排序来对索引1中的列表进行排序。这是为了一个学校项目，所以我没有使用快速排序算法。例如：
list = [[2, 5, 3],
[2, 4, 9],
[0, 9, 1],
[1, 1, 1],
[4, 7, 5]]
我希望能够做到这一点，按index1进行排序
quickSort(list)
output:
list = [[1, 1, 1],
[2, 4, 9],
[2, 5, 3],
[4, 7, 5],
[0, 9, 1]]
这是我的快速排序代
浏览 4提问于2014-01-15得票数 1
回答已采纳
1回答
我想测试quickSort的时间复杂度，但是我不知道如何生成数组来测试最好的情况。我的quickSort版本以数组的最后一个元素为轴心。
浏览 5提问于2019-10-28得票数 0
回答已采纳
3回答
我正尝试在python中就地实现快速排序。我在这里遵循了维基百科文章中的伪代码，但这并没有产生一个排序列表。有什么明显的错误吗？
# Perform QuickSort in place
def partition(arr,low,high):
pivotIndex = random.randint(0,high)
pivotValue = arr[pivotIndex]
currentIndex = low
t = arr[high]
arr[high] = pivotValue
arr[pivotIndex] = t
for i
浏览 4提问于2014-12-19得票数 0
回答已采纳
下面的程序使用数组的第一个元素作为支点进行排序，但是getParitionIndex并不像预期的那样工作。最后提出的具体问题/意见。
var quickSort = function (arr, left, right) {
if (left < right) {
const partitionIndex = getPartitionIndex(arr, left, right);
quickSort(arr, left, partitionIndex-1);
quickSort(arr, partitionIn
浏览 0提问于2018-03-30得票数 0
回答已采纳
我试图使用最后一个元素作为枢轴在Prolog中实现快速排序，但不知怎么我的谓词进入了一个无限循环。我使用累加器来确定到目前为止排序的部分(最终应该等于它应该寻找的排序列表S)。
quicksort([], S, S).
quicksort(L, S, A ) :-
lastElement(L, P), /*last element P as pivot*/
split(L, P, Greater, Smaller), /* splits L into set Greater (than) and Smaller (than) by pivot P */
quicksor
浏览 3提问于2017-04-12得票数 0
回答已采纳
我尝试使用在QuickSort上提到的算法来实现的代码。
但是，我无法得到排序的输出。相反，我只得到与输出相同的数组。
有人能帮我检查一下并告诉我我的代码出了什么问题吗？
public class QuickSort {
private int[] arr;
private void quick_sort(int[] input, int lo, int hi){
this.arr = input;
if(lo<hi){
int p = partition(arr, lo, hi);
if(lo < p-1)
浏览 2提问于2015-01-29得票数 3
回答已采纳
我正在尝试写一个程序来计算快速排序程序中的比较次数。
这是我的代码
package algo_quicksort;
public class Algo_quicksort {
public static int partition(int[]A,int p,int r){
int x=A[p];
int i=p+1;
int temp;
for(int j=p+1;j<r;j++){
if(A[j]<x){//if A[j] is bigger than the pivot do n
浏览 1提问于2013-08-06得票数 0
当我向这个方法发送一个大小大于900000的数组时，大约有一半的时间会得到一个StackOverflowError。请帮助我理解为什么会发生这种事，以及如何解决它。
public static void quicksort2(int[] xs, int lo, int hi){
int h,l,p,t;
if (lo<hi){
l = lo;
h = hi;
p = xs[hi];
do {
while( (l<h) && (xs[l] <= p) )
浏览 0提问于2018-04-23得票数 1
回答已采纳
2回答
快速排序的算法是：
Quicksort(A,p,r)
if p<r then
q<- partition(A,p,r)
Quicksort(A,p,q-1)
Quicksort(A,q+1,r)
根据我的注释，快速排序(A，1，n)的代价是T(N)=T(Q)+T(N)+分割成本。
为什么成本是这样而不是:t(N)=T(q-1)+T( not )+分割成本？
还有为什么最坏情况T(n)=T(n-1)+Θ(n)的代价？
浏览 3提问于2014-08-07得票数 0
回答已采纳
1回答
(: partition1 (All (A) ((A A -> Boolean) (Listof A) -> (Pr (Listof A) (Listof A)))))
(define (partition1 f x)
(match x
('() (Pr '() '()))
((cons hd '()) (Pr (list hd) '()))
((cons hd tl)
(match
(partition1 f tl)
((Pr A B)
(if (f h
浏览 0提问于2016-11-18得票数 0
当数组的大小低于40时，以下代码可以正确运行，但如果数组的大小较大，则会使其运行很长时间。请告诉我为什么是这样的。非常感谢。为什么网站总是告诉我要添加更多的细节。
以下是我的代码
#include<iostream>
using namespace std;
int Quicksort(int arr[], int l, int r) {
int p = arr[l];
int i = l+1;
for (int j = l+1; j <=r; j++){
if (arr[j] < p){
int tem
浏览 0提问于2015-02-12得票数 0
1回答
快速排序算法的实现
、、、
我目前正在做一个算法课程，并实现了这个版本的快速排序算法。我想知道这是否一个有效的实施。我看到了另外几个有分区函数的列表，这是一个比我做的更好的方法吗？
def quickSort(aList):
first = []
second = []
size = len(aList)
if size ==0:
return []
elif size == 1:
return aList
elif size ==2:
if(aList[1]<aList[0]):
return
浏览 0提问于2015-03-22得票数 2
回答已采纳
我创建了以下类来对字符串数组进行排序。
public class StringSort {
private String[] hotelNames;
private int arrayLength;
public void sortHotel(String[] hotelArray) {
if (hotelArray.length <= 1) {
return;
}
this.hotelNames = hotelArray;
arrayLength = hotelArray.length;
quicksort(0, arrayLe
浏览 0提问于2013-04-01得票数 0
回答已采纳
我正在尝试使用随机枢轴实现快速排序。
void QuickSort(int *arr,int left,int right){
if(right-left+1 > 2){
int i = 0,storeIndex = left;
int pivot = left + (int)(rand() % (right-left+1));
swap(&arr[pivot],&arr[right]);
for(i = left; i < right; i++){
if(arr[i] < arr[right]){
浏览 0提问于2013-08-04得票数 0
回答已采纳
2回答
我为同一个数组创建了一个快速排序的测试用例n=2,4，...2^16。我的快速排序可以工作(用标准数组测试)，现在我尝试测试2^16。我得到了以下错误： 9 512
Single iteration for time elapsed: 0.0088467 seconds.
10 1024
10 1024
Traceback (most recent call last):
File "quicksort1.py", line 37, in <module>
quicksort1(array_to_sort, low, high)
File
浏览 19提问于2019-10-04得票数 0
这是一个简单的快速排序，它使用数组，但我找不到为什么我会陷入无休止的递归中。最后，我得到的唯一结果是堆栈溢出错误。
List<Integer> quicksort(List<Integer> toSort){
if(toSort.size() > 1){
List<Integer> left = new ArrayList<>();
List<Integer> right = new ArrayList<>();
for(in
浏览 1提问于2020-06-01得票数 0
回答已采纳
3回答
我已经实现了一个有效的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
浏览 0提问于2012-03-03得票数 0
回答已采纳
3回答
我正在尝试实现快速排序算法，但我一直将列表索引超出范围。
在快速排序(数组，左，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]
浏览 3提问于2015-07-14得票数 2
回答已采纳
1回答
下面是我在没有分区函数的情况下进行快速排序的代码，并试图找出最坏和最好情况下的复杂性。你们中有人能帮我解释一下它是如何循环的还是一步一步的？
public static void quickSort(int a[], int first, int last)
{
int start=first,end=last;
int mid= (first+last)/2;
int temp;
while(start<=end)
{
while(a[start]<a[mid])
{
start=st
浏览 5提问于2015-09-19得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
