Алгоритмы пузырьковой сортировки Опции

[Account]

Итак, все знают что есть такой вид сортировки, как пузырьковая. Меня интересует какие еще есть алгоритмы в этом виде сортировки кроме: последовательного и чет-нечетной перестановки? И если есть информация о них поделиться ей, если не жалко.

[IUnknown]

     if (keepsmall) { /* Keep the nlocal smaller elements */ 

          // Этот кусок упорядочивает в массив elmnts минимальные значения из elmnts и
          // relmnts (которые получены от соседнего процесса) по возрастанию
          // (сколько поместится в elmnts) Скажем, если было:
          // elmnts = (27  39  54  74  90)
          // relmnts = (22  38  50  65  69)
          // то после выполнения нижеследующего куска кода
          // elmnts = (22  27  38  39  50)

          for (i=j=k=0; k<nlocal; k++) { 
               if (j == nlocal || (i < nlocal && wspace[i] < relmnts[j])) 
                    elmnts[k] = wspace[i++]; 
               else 
                    elmnts[k] = relmnts[j++]; 
          }
     } 
     else { /* Keep the nlocal larger elements */ 
          // Соответственно, этот кусок делает то же самое, но сохраняет nlocal максимальных
          // элементов из совокупности elmnts и relmnts. Т.е., если
          // elmnts = (16  18  47  62  70)
          // relmnts = ( 1  13  23  29  92), то в результате
          // elmnts = (29  47  62  70  92)
          // в упорядоченном виде
          for (i=k=nlocal-1, j=nlocal-1; k>=0; k--) { 
               if (j == 0 || (i >= 0 && wspace[i] >= relmnts[j]))
                    elmnts[k] = wspace[i--]; 
               else 
                    elmnts[k] = relmnts[j--]; 
          } 
     }

[Account]

     if (keepsmall) { /* Keep the nlocal smaller elements */ 

          // Этот кусок упорядочивает в массив elmnts минимальные значения из elmnts и
          // relmnts (которые получены от соседнего процесса) по возрастанию
          // (сколько поместится в elmnts) Скажем, если было:
          // elmnts = (27  39  54  74  90)
          // relmnts = (22  38  50  65  69)
          // то после выполнения нижеследующего куска кода
          // elmnts = (22  27  38  39  50)

          for (i=j=k=0; k<nlocal; k++) { 
               if (j == nlocal || (i < nlocal && wspace[i] < relmnts[j])) 
                    elmnts[k] = wspace[i++]; 
               else 
                    elmnts[k] = relmnts[j++]; 
          }
     } 
     else { /* Keep the nlocal larger elements */ 
          // Соответственно, этот кусок делает то же самое, но сохраняет nlocal максимальных
          // элементов из совокупности elmnts и relmnts. Т.е., если
          // elmnts = (16  18  47  62  70)
          // relmnts = ( 1  13  23  29  92), то в результате
          // elmnts = (29  47  62  70  92)
          // в упорядоченном виде
          for (i=k=nlocal-1, j=nlocal-1; k>=0; k--) { 
               if (j == 0 || (i >= 0 && wspace[i] >= relmnts[j]))
                    elmnts[k] = wspace[i--]; 
               else 
                    elmnts[k] = relmnts[j--]; 
          } 
     }

Правильно ли я понимаю, что

wspace[i--]//<---совокупность и elmnts и relmnts

и по сути из него выбирается опять же методом сравнения(как по твоему, если бы отсортировать его и потом просто делить, привело бы к уменьшению времени выполнения данного кода ?)

Сообщение отредактировано: Account - 27.06.2011 20:51