function which arranges the elements of an array in ascending order - arrays

Question

I try to create a function which arranges the elements of an array in ascending order. But the result isn't good. I think I have forgotten one thing... thanks for your help.
#include <stdio.h>
void ft_sort_int_tab(int *tab, int size) {
int i;
int j;
int temp;
size -= 1;
i = 0;
while (i < size) {
if (tab[i] > tab[i + 1]) {
temp = tab[i];
tab[i] = tab[i + 1];
tab[i + 1] = temp;
}
i++;
}
}
int main(void) {
int tab[9] = {9, 5, 2, 3, 8, 4, 16, 20, 24};
ft_sort_int_tab(tab, 9);
for (int i = 0; i < 9; i++) {
printf("%d ", tab[i]);
}
}
The result : 5 2 3 8 4 9 16 20 24

Answer 1

You've coded the inner-sweep loop of a bubblesort, but you apparently missed the point of the algorithm, as that's only half the algorithm.
Each pass of bubblesort swaps adjacent elements if they're out of order relative to each other (not the entire sequence). When a pass is finished, you're guaranteed the extreme value (largest or smallest, depending on your comparator choice) has found its home at the end of the swept partition. At that point, it should not be visited again. The next sweep run up to, but not include that element. Each sweep gets more and more elements closer to their proper homes, and at least one (the last one of that partition length) in its permanent home). As an optimization, you can track whether the current sweep every actually swapped any values.
Optionally, if the sweep completes with no swaps, you can eject entirely; the sequence is sorted. This attribute is what gives bubblesort its only redeeming quality. It is O(n) in best case, when the input sequence is already sorted when utilizing swap-detection. But it is also O(n^2) in general and worst case, making it a poor sorting choice in general.
Regardless
#include <stdio.h>
void ft_sort_int_tab(int *tab, int size)
{
while (size-- > 0) // note descending ceiling
{
int swapped = 0;
for (int i=0; i<size; ++i) // partition sweep
{
if (tab[i] > tab[i + 1])
{
int temp = tab[i];
tab[i] = tab[i + 1];
tab[i + 1] = temp;
swapped = 1;
}
}
if (!swapped) // early exit on no-swap sweep
break;
}
}
int main(void)
{
int tab[9] = {9, 5, 2, 3, 8, 4, 16, 20, 24};
ft_sort_int_tab(tab, 9);
for (int i = 0; i < 9; i++)
printf("%d ", tab[i]);
fputc('\n', stdout);
}
Output
2 3 4 5 8 9 16 20 24

Answer 2

It seems you are trying to implement the bubble sort algorithm.
Your function uses only one loop to move the maximum element in its target position. But you need to repeat the process for all other elements of the array.
The function can look the following way as it is shown in the demonstrative program below.
#include <stdio.h>
void ft_sort_int_tab( int *tab, size_t size )
{
for ( size_t last = size; !( size < 2 ); size = last )
{
for ( size_t i = last = 1; i < size; ++i )
{
if ( tab[i] < tab[i-1] )
{
int tmp = tab[i];
tab[i] = tab[i - 1];
tab[i - 1] = tmp;
last = i;
}
}
}
}
int main(void)
{
int tab[] = { 9, 5, 2, 3, 8, 4, 16, 20, 24 };
const size_t N = sizeof( tab ) / sizeof( *tab );
for ( size_t i = 0; i < N; i++ )
{
printf( "%d ", tab[i] );
}
putchar( '\n' );
ft_sort_int_tab( tab, N );
for ( size_t i = 0; i < N; i++ )
{
printf( "%d ", tab[i] );
}
putchar( '\n' );
return 0;
}
The program output is
9 5 2 3 8 4 16 20 24
2 3 4 5 8 9 16 20 24
Pay attention to that in general the number of elements in an array should be specified by an object of the type size_t. It is the type of the value returned by the operator sizeof. An object of the type int can be not enough large to store the possible number of elements in an array.
A more general approach is to add one more parameter to the function that will specify the criteria of sorting an array. With this approach you can for example sort an array either in the ascending order or in the descending order using the same one function.
Here is a demonstrative program.
#include <stdio.h>
int ascending( int x, int y )
{
return x < y;
}
int descending( int x, int y )
{
return y < x;
}
void ft_sort_int_tab( int *tab, size_t size, int cmp( int, int ) )
{
for ( size_t last = size; !( size < 2 ); size = last )
{
for ( size_t i = last = 1; i < size; ++i )
{
if ( cmp( tab[i], tab[i-1] ) )
{
int tmp = tab[i];
tab[i] = tab[i - 1];
tab[i - 1] = tmp;
last = i;
}
}
}
}
int main(void)
{
int tab[] = { 9, 5, 2, 3, 8, 4, 16, 20, 24 };
const size_t N = sizeof( tab ) / sizeof( *tab );
for ( size_t i = 0; i < N; i++ )
{
printf( "%d ", tab[i] );
}
putchar( '\n' );
ft_sort_int_tab( tab, N, ascending );
for ( size_t i = 0; i < N; i++ )
{
printf( "%d ", tab[i] );
}
putchar( '\n' );
ft_sort_int_tab( tab, N, descending );
for ( size_t i = 0; i < N; i++ )
{
printf( "%d ", tab[i] );
}
putchar( '\n' );
return 0;
}
The program output is
9 5 2 3 8 4 16 20 24
2 3 4 5 8 9 16 20 24
24 20 16 9 8 5 4 3 2

Answer 3

Your code swaps the two elements if needed, but then moves on to the next position in the array. In the beginning of your example, the 9 and 5 get swapped, so 5 ends up in the first position, but 5 never gets compared to other elements.
There are lots of sorting algorithms out there, and you should read about them. The one that your code seems most similar to is called “bubble sort.” To get there, modify your code do that it makes multiple passes over the array until the array is completely sorted. If you made a second pass, for example, the 5 and 2 would get swapped, and you’d be closer to a sorted result.
Bubble sort is not the fastest way to sort, but it’s easy to understand. Other ways include quicksort, mergesort, and heapsort. Wikipedia can explain each of those, and they’re worth looking into if your need better performance.