以下代码段是否是QuickSort的有效实现？

Question

I'm currently digging into the theoretical field of algorithms for university and I've implemented a version of the Quicksort based on how I understood the algorithm works. After that I've compared it to existing solutions and my implementation seems to be different than the once I've found. Maybe some experience people can give me feedback on this:

 function quicksort(array) { let leftIndex = 0 let rightIndex = array.length - 2 if (leftIndex >= rightIndex) { return array } let pivotIndex = array.length - 1 let finalPivotIndex; do { while (array[leftIndex] < array[pivotIndex]) { leftIndex++ } while (array[rightIndex] > array[pivotIndex]) { rightIndex-- } if (leftIndex < rightIndex) { array = quickSwap(leftIndex, rightIndex, array) } else { finalPivotIndex = leftIndex } } while (leftIndex < rightIndex) if (array[finalPivotIndex] > array[pivotIndex]) { array = quickSwap(finalPivotIndex, pivotIndex, array) } let leftPivotArray = array.slice(0, finalPivotIndex) let rightPivotArray = array.slice(finalPivotIndex + 1) let sortedLeftArray = quicksort(leftPivotArray) let sortedRightArray = quicksort(rightPivotArray) let mergedArray = sortedLeftArray.concat([array[finalPivotIndex]]) mergedArray = mergedArray.concat(sortedRightArray) return mergedArray } function quickSwap(firstIndex, secondIndex, array) { let tmp = array[firstIndex] array[firstIndex] = array[secondIndex] array[secondIndex] = tmp return array } 

Answer 1

First of all I wouldnt use a separate function just for swaping, this usually adds some overhead, you dont want that if it comes to large arrays.

I tested your code after translating it to python and it seems like its not working correctly, its broken, trying to find the reason at the moment.

EDIT :

I changed the code a bit, leaving the basic structure and it now seems to work properly:

(0) do

if (leftIndex > rightIndex){
        return array
    }

instead of

if (leftIndex >= rightIndex) {
        return array
    }

and add

if ((array.length <= 2) && (array[0] < array[1])){
        return array
    }

right after it (this is rather pseudo code didnt test it in java (was python))

the last block makes sure you leave the function once youre at the resursion end end not need to continue sorting the sub-array

(1) set the pivot to the middle of the array this way you get the log() perfaormance, with length-1 quicksort is not quicker than any other

(2) save the pivot in a local variable and not access it by index, the element behind the index might change

(3) remove the last if statement (array[finalPivotIndex] > array[pivotIndex]) { if you do the algorithm by hand on a simple array you see that this block actually changes back what you just did, this way you end up with a wrong result

hope thats all I changed, here is my code (in Python, should be similar to read) so you can compare and troubleshoot :

import random

def Quicksort(array):
    leftIndex = 0
    rightIndex = len(array)-2


    if(leftIndex > rightIndex): #(0)
        return array

    if(len(array) <= 2 and array[0] < array[1]):#(0)
        return array
    pivotIndex = int(len(array)/2) #(1)
    finalPivotIndex = pivotIndex

    rightIndex = len(array)-1
    pivot = array[pivotIndex] #(2)
    while True:
        while array[leftIndex] < pivot: #(2)
            leftIndex += 1
        while array[rightIndex] > pivot: #(2)
            rightIndex -= 1
        if leftIndex < rightIndex:
            array[leftIndex], array[rightIndex] = array[rightIndex], array[leftIndex] #swapping in python
            #swapping alternative (without extra function) :
            #tmp = array[leftiIndex]
            #array[leftIndex] = array[rightIndex]
            #array[rightIndex] = tmp
            #this way you save the function-call-overhead and the problem of passing the whole array to ten function and back, this could hurt the performance quite a bit
            print(array, pivot, leftIndex, rightIndex) #debugging / slows down quite a bit
        else:
            finalPivotIndex = leftIndex
            break
   # (3)
   # if(array[finalPivotIndex] > array[pivotIndex]):
   #     array[finalPivotIndex], array[pivotIndex] = array[pivotIndex], array[finalPivotIndex]
   #     print(array)

    leftPivotArray = array[0:finalPivotIndex+1]
    rightPivotArray = array[finalPivotIndex+1:]

    sortedLeftArray = Quicksort(leftPivotArray)
    sortedRightArray = Quicksort(rightPivotArray)
    mergedArray = sortedLeftArray+sortedRightArray

    return mergedArray

#how I generated the array for testing
array = []
for i in range(50):
    array.append(i)
array = random.sample(array, 50)
qsorted = Quicksort(array)
array.sort()
#testing the function against the python-implementation  --> returns true
print(qsorted == array)

Answer 2

The code in the question appears to be a variation of Hoare partition scheme, but it's creating slices of an array, when it can just use swaps on the original array, and pass indexes to the quicksort function. If wanted, I can try to debug the question's code later, but in the meantime, here is an example of a conventional Hoare partition scheme that uses pre-increment and pre-decrement, and avoids stack overflow by only using recursion on the smaller partition, and looping back for the larger partition. On my system, using Chrome, it takes less than 2 seconds to sort the 10 million values.

 function quicksort(a, lo, hi) { while (lo < hi){ var p = a[Math.floor(lo+(hi-lo)/2)]; var i = lo - 1; var j = hi + 1; var t; while (true){ while (a[++i] < p); while (a[--j] > p); if (i >= j) break; t = a[i]; a[i] = a[j]; a[j] = t; } if(j - lo < hi - j){ quicksort(a, lo, j); lo = j+1; } else { quicksort(a, j+1, hi); hi = j; } } } var arr = new Array(10000000) for (i = 0; i < arr.length; i++) { arr[i] = parseInt(Math.random() * 1000000000); } console.time('measure'); quicksort(arr, 0, arr.length-1); console.timeEnd('measure'); for (i = 1; i < arr.length; i++) { if(arr[i-1] > arr[i]){ console.log('error'); break; } }