为什么我的 selectionSort 实现比我的 bubbleSort 实现快？

Question

I am trying to implement the selection sort algorithm in c. I don't know whether this is a correct implementation, and why my algorithm is much quicker than bubbles sort. Therefore, I am asking if you can tell me is correct or not and any improvement I have to make.

main(){
    
    srand(time(NULL));
    system("color b");
    
    int A[NUM],i;
    
    for(i=0;i<NUM;i++){
        A[i] = rand()%30000;
    }
    
    displayArray(A);
    SelectionSort(A);   
    displayArray(A);
        
    system("pause");
}

void displayArray(int * A){
    
    int i;
    for(i=0;i<NUM;i++){
        printf("%6d ", A[i]);
    }
    printf("\n");
}


void SelectionSort(int * A){
    
    int i,j,k, pos; 
    for(i=0;i<NUM;i++){
    
        k = A[i];
        for(j=i+1;j<NUM;j++){
            if(k >= A[j]){
                pos = j;
                k = A[j];
            }
        }
        A[pos] = A[i];
        A[i] = k;
        
    }
    
}

Answer 1

You should check it with the output of qsort() .
Fill 2 arrays with this loop

int A[NUM], B[NUM], i, n;

for(i=0;i<NUM;i++){
    n = rand()%99999*rand()%99999;
    A[i] = B[i] = n;
}

Then define a compare function, like this:

int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

And use it to call qsort() from the standard library and sort B

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))

The last step will be to compare A and B for a good number of random generated arrays. If they're equal, your implementation works.
Of course this is not mathematical proof, but if you're working on Selection sort, you'll be fine with empirical testing

Answer 2

Yes in this particular case your function is correct but in general there are at least three more or less serious drawbacks in the function.

The first one is that the function depends on the magic number NUM . So you can not use the function with any array with a different number of elements.

The second one is that you should not swap elements of the array with equal values. That is instead of this condition

if(k >= A[j]){

You should use the following condition

if(k > A[j]){

The third one is that you can not use the function to sort an array in the descending order or using some other criteria of sorting.

At least your function should not depend on a magic number.

For integer arrays I would declare and define the function the following way.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void selection_sort( int a[], size_t n, int cmp( const void *, const void * ) )
{
    for ( size_t i = 0; i < n; i++ )
    {
        size_t pos = i;
        
        for ( size_t j = i + 1; j < n; j++ )
        {
            if ( cmp( a + j, a + pos ) < 0 )
            {
                pos = j;
            }
        }
        
        if ( pos != i )
        {
            int tmp = a[i];
            a[i] = a[pos];
            a[pos] = tmp;
        }
    }
}

int ascending_order( const void *p1, const void *p2 )
{
    int a = *( int * )p1;
    int b = *( int * )p2;
    
    return ( b < a ) - ( a < b );
}

int descending_order( const void *p1, const void *p2 )
{
    int a = *( int * )p1;
    int b = *( int * )p2;
    
    return ( a < b ) - ( b < a );
}

int main(void) 
{
    enum { N = 20 };
    int a[N];
    
    srand( ( unsigned int )time( NULL ) );
    
    for ( size_t i = 0; i < N; i++ )
    {
        a[i] = rand() % N;
    }
    
    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );
    
    selection_sort( a, N, ascending_order );
    
    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );
    
    selection_sort( a, N, descending_order );
    
    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );
    
    return 0;
}

The program output might look like

2 10 1 2 14 8 0 17 13 11 5 12 9 3 13 13 3 12 4 1 
0 1 1 2 2 3 3 4 5 8 9 10 11 12 12 13 13 13 14 17 
17 14 13 13 13 12 12 11 10 9 8 5 4 3 3 2 2 1 1 0 

The function can be written in a more general form when it can be applied to an array of any type similarly to the standard C function qsort . But it is a more complicated task.

Answer 3

As L.Grozinger already commented , two algorithms having the same complexity does not mean that they will be equally fast. It only means that if you scale the input by some factor, the running time of both algorithms will increase by the same proportion.

For example, suppose that you first run both bubbleSort and selectionSort on an input of 100 elements. You might, for example, find that bubbleSort takes 4 milliseconds while selectionSort needs only 3 milliseconds. If you now scale the input by a factor two, ie, to 200 elements, you'll find that both algorithms take about four times as long: the running time of bubbleSort jumps from 4 ms to 16 ms, while the running time of selectionSort jumps from 3 to 12 ms.

BubbleSort is actually known to be slower than selectionSort. To see why this is the case, consider that comparison sorting algorithms (a family that bubbleSort and selectionSort are both members of) need to do two kinds of things: comparing and swapping. Both algorithms need to perform O(N^2) comparisons in order to sort a list, which is why both have an overall complexity of O(N^2). But selectionSort needs only O(N) swaps, where bubbleSort needs O(N^2) swaps. The big O notation normally hides this fact, because it abstracts away details about particular operations.

A similar thing is going on with quickSort and heapSort. They are both O(n log n), but heapSort makes way more cache misses than quickSort. That's why quickSort is much, ahem, quicker .

BubbleSort serves only an educational purpose; it is in all respects worse than both insertionSort and selectionSort. In fact, this is the reason why it serves an educational purpose.