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

快速排序算法基本逻辑

 1 //交换位置
 2 void Swap(int k[],int low,int high)
 3 {
 4     int temp;
 5     
 6     temp=k[low];
 7     k[low]=k[high];
 8     k[high]=temp;
 9 }
10 
11 //把大于基准点的数放在基准点右边，小于基准点的数放在基准点左边,返回新的基准点
12 int Partition(int k[],int low,int high)
13 {
14     int point;
15     point=k[low]; 
16     while(low<high)    
17     {
18         while(low<high&&k[high]>=point)
19         {
20             high--;
21         }
22         Swap(k,low,high);
23          
24         while(low<high&&k[low]<=point)
25         {
26             low++;
27          
28         Swap(k,low,high);
29     
30     }
31     
32     return low;
33 }
34 
35 void QSort(int k[],int low,int high)//low=数组起始位置下标 , high=数组结束位置下标
36 {
37     int point;//基准点
38     if(low<high)
39     {
40         point=Partition(k,low,high);
41         
42         QSort(k,low,point-1);
43         QSort(k,point+1,high);
44     }
45 }
46 
47 void QuickSort(int k[],int n)
48 {
49     QSort(k,0,n-1);
50 
51 }
52 
53 int main(){
54     int i,a[10]={5,2,6,8,3,9,1,7,4,0};
55     
56     QuickSort(a,10);
57     printf("排序后的结果是：");
58     for(i=0;i<10,i++)
59     {
60         printf("%d",a[i]);
61     }
62     printf("\n\n");
63     
64     return 0;
65 }

快速排序算法的优化

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
}

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

猜你喜欢