快速排序算法_逻辑及优化

快速排序算法基本逻辑

//交换位置
void Swap(int k[],int low,int high)
{
    int temp;
    
    temp=k[low];
    k[low]=k[high];
    k[high]=temp;
}

//把大于基准点的数放在基准点右边，小于基准点的数放在基准点左边,返回新的基准点
int Partition(int k[],int low,int high)
{
    int point;
    point=k[low]; 
    while(low<high)    
    {
        while(low<high&&k[high]>=point)
        {
            high--;
        }
        Swap(k,low,high);
         
        while(low<high&&k[low]<=point)
        {
            low++;
         
        Swap(k,low,high);
    
    }
    
    return low;
}

void QSort(int k[],int low,int high)//low=数组起始位置下标 , high=数组结束位置下标
{
    int point;//基准点
    if(low<high)
    {
        point=Partition(k,low,high);
        
        QSort(k,low,point-1);
        QSort(k,point+1,high);
    }
}

void QuickSort(int k[],int n)
{
    QSort(k,0,n-1);

}

int main(){
    int i,a[10]={5,2,6,8,3,9,1,7,4,0};
    
    QuickSort(a,10);
    printf("排序后的结果是：");
    for(i=0;i<10,i++)
    {
        printf("%d",a[i]);
    }
    printf("\n\n");
    
    return 0;
}

 

快速排序算法的优化

1、优化选取基准点： 尽量选取中间值，避免选取极端点，降低递归深度

2、优化不必要的交换

//把大于基准点的数放在基准点右边，小于基准点的数放在基准点左边,返回新的基准点
int Partition(int k[],int low,int high)
{
    int point;
    
    
    //优化一 在起始点、中间点、尾点 3个元素之间选取中间值作为基准点
    int m=low+(high-low)/2;  
    
    if(k[low]>k[high])
    {
        Swap(k,low,high);
    }
    if(k[m]>k[high])
    {
        Swap(k,m,high);
    }
    if(k[m]>k[low])
    {
        Swap(k,m,low);
    }
    //end
    
    point=k[low]; 
    
    //优化二 直接赋值，避免基准点位置换来换去
    while(low<high)    
    {
        while(low<high&&k[high]>=point)
        {
            high--;
        }
        k[low]=k[high];
         
        while(low<high&&k[low]<=point)
        {
            low++;
         
        k[high]=k[low];
    }
    k[low]=point;
    //end
    return low;
}

 

3、优化小数组的排序：使用直接插入排序

   

void QSort(int k[],int low,int high)//low=数组起始位置下标 , high=数组结束位置下标
{
    int point;//基准点
    
    //优化三 数组长度大于7时调用快速排序，数组长度小于7时调用直接插入排序
    if( high-low > MAX_LENGTH_INSERT_SORT )
    {
        point=Partition(k,low,high);
        
        QSort(k,low,point-1);
        QSort(k,point+1,high);
    }
    else
    {
        InsertSort(k,low,high);//直接插入排序
    }
    //end
}

#define MAX_LENGTH_INSERT_SORT 7

void ISort(int k[],int n)
{
    int i,j,temp;
    
    for(i-1;i<n;i++)
    {
        if(k[i]<k[i-1])
        {
            temp=k[i];
            
            for(j=i-1;k[j]>temp;j--)
            {
                k[j+1]=k[j];
            }
            
            k[j+1]=temp;
        }
    }
}

void InsertSort(int k[],int low,int high)
{
    ISort(k+low,high-low+1);
}

 

4、优化递归操作：使用尾递归

  

 

void QSort(int k[],int low,int high)//low=数组起始位置下标 , high=数组结束位置下标
{
    int point;//基准点
    
    //优化三 数组长度大于7时调用快速排序，数组长度小于7时调用直接插入排序
    if( high-low > MAX_LENGTH_INSERT_SORT )
    {
        point=Partition(k,low,high);
        
        //优化四 分部分，化为尾递归
        if(point-low<high-point)
        {
            QSort(k,low,point-1);
            low=point+1;
        }
        else
        {
            QSort(k,point+1,high);
            high=point-1;
        }
        //end
    }
    else
    {
        InsertSort(k,low,high);//直接插入排序
    }
    //end
}