有人可以向我解释这是什么类型的吗？

Question

I found this sort, can someone explain to me what type of sort it is? Am i right to think this is a selection sort? How are the nested loops working?

    for (i = 0; i < N; ++i) { 
        for (j = i + 1; j < N; ++j) {
            if (toSort[i] > toSort[j]) {
                temp = toSort[i];
                toSort[i] = toSort[j];
                toSort[j] = temp;

                printf("%d is swapped with %d\n", toSort[i], toSort[j]);  
            }
        }
    }

Answer 1

The algorithm you posted looks like bubble sort, but it has a few mistakes. See its pseudocode below:

procedure bubbleSort(list : array of items)

   loop = list.count;

   for i = 0 to loop-1 do:
      swapped = false

      for j = 0 to loop-1 do:

         if list[j] > list[j+1] then
            swap(list[j], list[j+1]) 
            swapped = true
         end if

      end for

      if not swapped then
         break
      end if

   end for

end procedure return list

This is an optimized version of bubble sort, which uses a boolean "flag" to skip unnecessary iterations.

Selection sort is different as it looks for the smallest number and inserts it in its final place. The pseudocode for selection sort is as follows:

procedure selection sort 
   list  : array of items
   n     : size of list

   for i = 1 to n - 1
      min = i    

      for j = i+1 to n 
         if list[j] < list[min] then
            min = j;
         end if
      end for

      if indexMin != i  then
         swap(list[min], list[i])
      end if
   end for

end procedure

Answer 2

This looks like a variation of Bubble sort, with the exception that it seems wrong . Here, the inner loop looks doing a reverse job compared to the classical Bubble sort. In the classical version, inner loop "pops up" the current i-th element until it is on its place. In this version it tries to "sink down" the i-th element. However, note that the the j-th element is swapped with i-th all the time, and so as long as i is fixed while we're in j-loop, we do a mess of j-th elements while all of them are less than i-th. The i-th is modified with j-th, and then the (j+1)-th element is in fact compared to j-th. This is wrong (at least that is not what the classical Bubble sort does).