聚集相同的元素

聚集和基准相同的元素

使和基准元素相同的元素靠近基准位置，重新定义left与right位置

原理

代码

public class Test2 {
    /**
     * 找基准
     * @param array
     * @param low
     * @param high
     * @return
     */
    public static int partion(int[] array,int low,int high){
        int tmp = array[low];
        while(low<high){
            //从high位置寻找比tmp小的值
            while(low < high && array[high] >= tmp){
                --high;
            }
            if(low >= high){
                //表明low与high相遇
                break;
            }else{
                array[low] = array[high];
            }
            //从low位置寻找比tmp大的值
            while(low < high && array[low] <= tmp){
                ++low;
            }
            if(low >= high){
                //表明low与high相遇
                break;
            }else{
                array[high] = array[low];
            }
        }
        array[low] = tmp;
        return low;
    }
    /**
     * 聚集和基准相同的元素
     * @param array
     * @param start
     * @param end
     * @param par
     * @param left
     * @param right
     * @return
     */
    public static int[] focurNum(int[] array,int start,int end,int par,int left,int right){
        /**
         * 左边找
         */
        //parLeft与parRight初始化为基准位置的左右
        int parLeft = par-1;
        int parRight = par+1;
        //tmp用于交换
        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再往后走一位
                    parLeft--;
                }else{
                    //如果相等则说明该位的值已经与基准相同不必交换
                    parLeft--;
                }

            }
        }
        //确定left新值
        left = 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;
        //定义数组存放新的左右下标
        int[] brray = new int[2];
        brray[0] = left;
        brray[1] = right;
        return brray;
    }

    public static void Quick(int[] array,int start,int end){
/*      if(end-start+1 < 100){
            shellshellshell.insert(array,start,end);
            return;
        }*/ 
        int par = partion(array,start,end);
        int left = par-1;;
        int right = par+1;
        int[] brray = focurNum(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,45,12,46,12,13,12,2};
        QuickSort(array);
        System.out.println(Arrays.toString(array));
    }

}

结果