相同元素聚集法 快速排序的一种优化

在一次分割结束后可以把与par相等的元素聚集在一起，继续下次分割时，不用再对与par相等元素分割

 举例：

待排序序列 1 4 6 7 6 6 7 6 8 6

划分后，对与par元素相等处理的结果：1 4 6 6 6 6 6 7 8 7

下次的两个子序列为：1 4 和 7 8 7

经过对比，我们可以看出，在一次划分后，把与par相等的元素聚在一起，能减少迭代次数，效率会提高不少

具体过程：在处理过程中，会有两个步骤

第一步，在划分过程中，把与key相等元素放入数组的两端

第二步，划分结束后，把与key相等的元素移到par周围

 

 

//聚集相同元素法




package sort;

import java.util.Arrays;
/*
 * 快速排序的一种优化
 
 *
 */
public class TestQuickSort3 {
    //一趟快排
    public static int partion(int []array,int low,int hign){
        
        int tmp=array[low];
        while(low<hign){
            while(low<hign&&array[hign]>=tmp){
                --hign;
            }
            if(low>=hign){
                break;
            }else{
                array[low]=array[hign];
            }
            while(low<hign&&array[low]<=tmp){
                ++low;
            }
            if(low>=hign){
                break;
            }else{
                array[hign]=array[low];
            }
        
    }
        array[low]=tmp;
        return low;
    
}
    //定义聚集方法
    public static int[] focusNum(int [] array,int start,int end,int par,int left,int right) {
        int parLeft=par-1;
        int parRight=par+1;
        int tmp=0;
     //左边寻找
        for(int i=par-1;i>=start;i--){
            if(array[i]==array[par]){
                if(i!=parLeft){
                    tmp=array[parLeft];
                    array[parLeft]=array[i];
                    array[i]=tmp;
                    parLeft--;
                }else{
                    parLeft--;
                }
            }
        }
     //右边寻找
        for(int j=par+1;j<=end;j++){
            if(array[j]==array[par]){
                if(j!=parRight){
                    tmp=array[parRight];
                    array[parRight]=array[j];
                    array[j]=tmp;
                    parRight++;
                }else{
                    parRight++;
                }
            }
        }
        right=parRight;//聚集的相同元素最右边的一个非相同元素
        left=parLeft;//聚集的相同元素最左边的一个非相同元素
        int[]brray=new int[2];
        brray[0]=left;
        brray[1]=right;
        return brray;
    }
    public static void Quick(int[]array,int start,int end){
        int par=partion(array,start,end);
        int left=par-1;
        int right=par+1;
        int[]brray=focusNum(array,start,end,par,left,right);
        left=brray[0];
        right=brray[1];
        
        if(par>start+1){//左边还需要快排
            Quick(array,start,left);
        }
        if(par<end-1){//右边还需要快排
            Quick(array,right,end);
        }
        
        
    }
    
    public static void QuickSort(int[]array){
        Quick(array,0,array.length-1);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[]array={1, 4, 6, 6, 6, 6, 6, 7, 7, 8}; 
          QuickSort(array); 
          System.out.println(Arrays.toString(array)); 
    }

}