Bubble sort concept - c

Question

I just want the explanation about the condition in nested for loop.
How its processing, i am bit confused. I want the logic behind the conditions of two for loops.
#include<stdio.h>
void bubblesort(int a[25],int n);
int main()
{
int a[25],size,i;
printf("Enter the size of an array");
scanf("%d",&size);
for(i=0;i<size;i++)
{
scanf("%d",&a[i]);
}
bubblesort(a,size);
for(i=0;i<size;i++)
{
printf("%d\t",a[i]);
}
return 0;
}
void bubblesort(int a[], int n)
{
int temp,i,j;
for(i=0;i<n;i++)
{
for(j=0;j<(n-i)-1;j++)
{
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]= temp;
}
}
}
}

Answer 1

Bubble sort is a commonly used algorithm for sorting an array of integers. It's called "bubble sort" since it causes the largest values to "bubble" up to the end of the array.
Bubble sort moves one index at a time up the array essentially pulling the largest value along. For example, If the array is [1,3,2] bubble sort will check the 1 and see if it is greater than the value ahead of it: 3. It isn't so the one will stay in its place. Now the 3 is the largest value the program has seen so it will compare it to the next value, the 2. Is 3 bigger? Yes! So it will switch the 3 and the 2. Now the largest value is at the end of the array so the algorithm starts at the beginning of the array again. This repeats until the entire array is sorted.
On to the specifics:
The first for-loop for(i=0;i<n;i++) loops for the same amount of times as the size of the array, i.e. if the size is 7, this loops will execute 7 times. It does this because, in the worst case scenario, every value in the array will need to change location.
The inner-most for-loop for(j=0;j<(n-i)-1;j++) first of all has j never reaching the very last array spot, even when i = 0. This is because the code inside the loop, if(a[j]>a[j+1]), is always checking one value AHEAD of the current index. So, j must never equal the last value of the index because there will be an out of bounds error.
You will also notice that the inner-more for-loop goes from 0 to n-i-1. The reason this -i is included is because every time the outer loop, if(a[j]>a[j+1])`, is executed, one value will have moved all the way up to the end of the array. So you don't need to check the very last spot in the array because it's already correct!
Summary:
Bubble sort continually moves the largest value to the end of the list. It does this by constantly checking values as it moves up the list and moving the largest value up one step at a time.
Edit: See Cool Guy's comment for a link to a great visual representation of bubble sort.