排序算法感想1

先来分析一下o(n*n)的算法:

第一种：插入排序：

插入排序的时候可以一边比较一边交换。顺便运用了冒泡的思想。

代码：

For(i=1;i<=n;i++)

         For(j=I;j>0;j--)

{

If(array[j]>array[j-1])

         Swap(array[j],array[j-1]);

}

         优化算法：

         先找i的位置，找的时候就把那些需要往后面移动的就移动了，这个时候是一次赋值操作，所以比较快。

         再一步优化：

的时候可以用二分查找那个I的位置。

二分查找代码：

         While（left<=right）

         {

                   Middle=(left+right)/2;

                   If(temp<array[middle])//保证排序是稳定的。  

                            Right=middle-1;

                   Else

                            Right=middle+1;

         }

         Left就是那个位置、

         冒泡排序：

         代码：

         For(i=1;i<n;i++)

                   For(j=n-I;j>=I;j--)

                   {

                            If(array[j]<array[j-1])

                                     Swap(array[j],array[j-1]);

                   }

         改进算法：可以设置一个标志位看什么时候没有交换的时候就可以退出了。

         直接选择排序：

         它是不稳定的，因为它一旦就是调换过后，被调换的元素就具有了不稳定性。

         代码：

         Int small;

         For(i=0;i<n-1;i++)

         {

                   Small=I;

                   For(j=i+1;j<n;j++)

                            If(array[j]<small)

                                     Small=j;

                   Swap(array[small],array[i]);

         }

         Shell排序：

         产生原因：针对直接插入排序在有序的时候时间复杂度可以精简为o(n)。对于短序列，插入排序也比较有序。

         代码：

         For(delta=n/2;delta>0;delta/=2)   //确定间隔

                   For(i=delta;i<n;i++)                                      

{

                            For(j=i;j>=0;j-=delta)    

                                     If(a[j]<a[j-delta])

                                                        Swap(a[j],a[j-delta]);

                   }