qsort与插入排序混合优化

class SortOp
{ //插入排序
        private static void InsertSort(int[] list,int low,int high)
        {
            for (int i = low; i < high; i++)
            {
                int t = list[i];
                int j = i;
                while ((j > 0) && (list[j - 1] > t))
                {
                    list[j] = list[j - 1];
                    --j;
                }
                list[j] = t;
            }
        }
    
 
    
           private static void Swap(ref int i, ref int j)
            //只有两个元素时直接交换
            {
                int t;
                t = i;
                i = j;
                j = t;
            }
            //快速排序优化
            public static void QuickSort(int[] list, int low, int high,int k)
            {  
                //只剩下一个无需交换
                if (high <= low)
               {
                    return;
                }
                else if (high == low + 1)
               {
                    //只剩下两个直接交换
                    if (list[low] > list[high])
                    {                   
                        Swap(ref list[low], ref list[high]);
                        return;
                    }
                }
                //大于三个元素开始优化的快速排序
                myQuickSort(list, low, high,k);
            }
 
            public static void myQuickSort(int[] list, int low, int high,int k)
           {
                if (low < high)
                {
                    if(high-low<k)           //子序列小于k个使用插入排序
                    {
                    InsertSort(list,low,high);
                    }
                    else{
                    int pivot = Partition(list, low, high);
                    myQuickSort(list, low, pivot - 1,k);
                    myQuickSort(list, pivot + 1, high,k);
                    }
                }
            }
 
            private static int Partition(int[] list, int low, int high)
            {
                int pivot;
                pivot = list[low];
                while (low < high)
              {
                    while (low < high && list[high] >= pivot)
                   {
                        high--;
                    }
                    if (low != high)
                    {
                        Swap(ref list[low], ref list[high]);
                        low++;
                    }
                    while (low < high && list[low] <= pivot)
                    {
                        low++;
                    }
                    if (low != high)
                    {
                        Swap(ref list[low], ref list[high]);
                        high--;
                    }
                }
                return low;
            }
 
}

 

1、 经过优化以后的快速排序比传统快速排序的速度要快，通过数据计算可以排序速度提高了10%-20%左右。

2、 在规模不大（例如5个数量级以下）的排序中其最佳的k的取值往往比log n大，一般以8—12之间效率最佳。

当规模较大时，k的取值一般取logn为宜，即使最佳取值超过logn其性能提升也不明显。

一般的qsort

 void inline quickSort(int[] array,int start,int end)
 {
     int i,j,sign,tmp;
       /* 有可能造成start>end   因为递归调用时j+1，可能引起j比end还大1。  另外如果数组是空的，或者输入错误也会出现这种情况*/
       if(end<=start)
       {
           return;          
       }
       else
       {
           /* 取中间元素为中心点，然后移到最右边 */
           sign=(start+end)/2;
           tmp=array[end];
           array[end]=array[sign];
           array[sign]=tmp;
           j=start;
           for(i=start;i<=end-1;i++)
           { 
              /* 小于的元素和标记互换，等于的不能互换，否则会形成死循环 */
              if(array[i]<array[end]) 
              {                
                   tmp=array[i];
                   array[i]=array[j];
                   array[j]=tmp;
                   j=j+1;
              }         
           }
           /* 把标记元素和第一个>=它的元素位置互换，这样数组就分成2个部分，一个部分比中心值小，一个部分比中心值大 */
           tmp=array[j];
           array[j]=array[end];
           array[end]=tmp;
           quickSort(array,start,j);
           quickSort(array,j+1,end);
       }
}