Bubble sort - roznice w implementacjach

void swap(int *xp, int *yp)
{
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}
 
// A function to implement bubble sort
void bubbleSort(int arr[], int n)
{
   int i, j;
   for (i = 0; i < n-1; i++)      
 
       // Last i elements are already in place   
       for (j = 0; j < n-i-1; j++) 
           if (arr[j] > arr[j+1])
              swap(&arr[j], &arr[j+1]);
}

void BubbleSort (int a[], int length)
{
	int i, j, temp;
	
    for (i = 0; i < length; i++)
    {
        for (j = 0; j < length - 1; j++)
        {
            if (a[j + 1] < a[j])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

Dwie implementacje tego samego sortowania. Może mi ktoś napisać jakie są różnice między nimi? To znaczy.. Wiem, że w pierwszym działamy na wskaźnikach i używamy dodatkowej funkcji swap(); natomiast w drugim używamy operatora przypisania.

Drugi kod jest krótszy ale który jest bardziej wydajny? Mój tok rozumowania jest następujący: -> działając na wskaźnikach nie tworzymy dodatkowych zmiennych jak w przypadku drugiej implementacji bubble sorta przez co kod będzie wydajniejszy. Jest jeszcze jakiś powód dla którego nie powinienem korzystać z drugiej implementacji sortowania? dzięki, rozjaśni mi to wiele :)

działając na wskaźnikach nie tworzymy dodatkowych zmiennych jak w przypadku drugiej implementacji bubble sorta

A tutaj?

void swap(int *xp, int *yp)
{
    int temp = *xp; // Dodatkowa zmienna
    *xp = *yp;
    *yp = temp;
}

Różnica jest jeszcze w warunkach drugich pętel:

// Pierwszy kod:
for (j = 0; j < n-i-1; j++)  // Zauważ że tutaj jest n - i - 1
// Drugi:
for (j = 0; j < length - 1; j++) // To samo co n - 1 (bez i)

Który kod powinieneś używać? Powiedziałbym że ten z funkcją swap(), dlaczego? Dlatego że:

• Jest czytelniejszy - wywołując swap() od razu wiadomo co się stanie.
• Bardzo prawdopodobne jest to że takich zmian miejscami będzie kilka (w różnych miejscach w kodzie), wtedy zamiast klepać te 3 linijki w każdym miejscu wystarczy wywołać funkcję swap().

Nie pisałem tutaj o tworzeniu zmiennych pomocniczych tylko zmiennych które będą przechowywać zmienne wywołujące z głównej funkcji main. Działając na wskaźnikach nie są tworzone kopie tych zmiennych tylko działamy bezpośrednio na nich. Right?

Tak bezpośrednio na nich też nie działasz, tylko przez wskaźnik który sam w sobie jest zmienną.
W obu przypadkach tworzysz zmienną temp która jest kopią jednej z wartości.

ok wygląda to następująco gdyby ktoś napotkał ten temat.

http://www.learncpp.com/cpp-tutorial/6-8-pointers-and-arrays/
http://www.learncpp.com/cpp-tutorial/6-8a-pointer-arithmetic-and-array-indexing/

W C++ wysyłając tablice (array) jako argument do funkcji nie tworzy się kopia jak w przypadku np. zmiennych. Dlatego też obie deklaracje działają tak samo:

-> void  nazwa_funkcji  ( int array[] )
-> void  nazwa_funkcji  ( int* arrray )

idąc dalej tym tokiem.. Gdy już wyślemy w jeden z powyższych sposobów naszą tablice do funkcji to w obu przypadkach (bo oznaczają to samo) działamy bezpośrednio na tych tablicach.
Jeżeli nie chcemy zmieniać naszej tablicy wysyłając jej do funkcji to musimy użyć stałą CONST.

tzn używamy const w funkcji czyli

->   void  nazwa_funkcji  (const int array[])   // albo ten drugi sposób ;o