快速排序算法+归并排序 java实现

 1 public class QuickRank {
public static void main(String[] args) {
    int[] original={26,58,1,24,75,69,32,45,841,25898};
    QuickRank quickRank=new QuickRank();
    quickRank.rankSimple(original,0,original.length-1);
    for(int i:original)
        System.out.println(i);
}
//清晰明了
public void rankSimple(int[] original,int start,int end){
        if(end<=start) return;//递归结束条件
        int standard=original[start];
        int leftOrder=start;
        int rightOrder=end;
        while(leftOrder<rightOrder){
            //从右往左跑
            while(leftOrder<rightOrder && original[rightOrder]>standard)
                rightOrder--;
            original[leftOrder]=original[rightOrder];
            //从左往右跑
            while(leftOrder<rightOrder && original[leftOrder]<standard)
                leftOrder++;
            original[rightOrder]=original[leftOrder];
        }
        original[leftOrder]=standard;
        //递归开始
        rankSimple(original, start, leftOrder-1);
        rankSimple(original, leftOrder+1, end);
    }
}

结果：
1
24
26
32
45
58
69
75
841
25898

快速排序算法的思想：

　　1.一次排序（在排序结束之前，数组中始终有一个位置看为“空值”，该位置待插入数据）：

　　　　①随便取待排序数组的一个值（本例取第一个值）作为本次排序的基准值standard，原数组该值得位置可看成空值，待插入。

　　　　②从待排序数组右往左，依次比较每个值与standar的大小，如果有比standard小的，则将该值插入数组中的空值区域，此时，该值在数组中的位置看成 空值。

　　　　③从待排序数组左往右，依次比较每个值与standar的大小，如果有比standard大的，则将该值插入数组中的空值区域，此时，该值在数组中的位置看成空值。

　　　　④循环②③步骤，直到从右往左和从左往右的序号相等；表明本次排序结束，将standard放入该序号位置。此时，该序号前所有数字都小于standard，序号后所有的数字都大于standard，形成两个小的数组；

　　2.迭代

　　　　通过一次排序步骤后，便得到standard前后两个数组，然后分别将这两个数组进行一次排序，并迭代进行；

　　3.迭代结束标志:

　　　　进入一次排序的数组开始位置和结束位置相等，即传进来的是一个数字，不再需要排序；

 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------

/**
 *  归并排序：
 *      1.先归并：将两个排好序的数组合并为一个数组；
 *      2.进行递归
 *  
 * ***/
public class guiBingSort{
    public static void main(String[] args) {
        int[] input={1,273,54,59,76,585,14};
        diedai(input,0,input.length-1);
        for(int a:input)
            System.out.println(a);
    }
    //合并两个已经排好序的子数组，传入的数组左右子数组至少包括一个值，这也是后面迭代结束的标志end>start的来源
    public static void merge(int[] input,int start_order,int middle_order,int end_order){
        int[] temp_array=new int[end_order-start_order+1];
        int a=start_order;//左子数组起始位置；
        int b=middle_order+1;//右子数组起始位置；
        int c=0;
        while(a<=middle_order && b<=end_order)
        {
            if(input[a]<input[b])
                temp_array[c++]=input[a++];
            else temp_array[c++]=input[b++];
        }
        while(a<=middle_order)
            temp_array[c++]=input[a++];
        while(b<=end_order)
            temp_array[c++]=input[b++];
        c=0;
        for(int i=start_order;i<=end_order;i++)
            input[i]=temp_array[c++];
    }
    /**
     * @param input:输入的数组
     * @param start:表示该次迭代的子数组的开始下标，如第一次是0；
     * @param end:表示该次迭代的子数组的结束为止下标，如第一次是数组长度减一;
     * 
     * **/
    //进行迭代，迭代结束的标志就是start>end,也就是说只剩自己一个值了，当然不需要继续迭代了；
    public static void diedai(int[] input,int start,int end){
        int middle=(end+start)/2;
        if(end>start)
        {
            diedai(input, start, middle);
            diedai(input, middle+1, end);
            merge(input, start,middle, end);
        }
        return ;
    }
} 

该归并排序思想：

　　1.输入一个初始数组，每次通过改变起始位置来选取子数组进行迭代合并；

　　2.首先，考虑两个已排好序子数组的合并。即本代码中的merge方法；

　　3.其次，使用迭代的方式来一层一层的抽丝剥茧，直到end>start为止，此为迭代截止标志。因为归并排序的目的就在于，两个只有一个值的数组即两个已经排好序的数组，这时就可以合并了，合并之后的数组依然为排好序的。这样就一步步的返回了，直到所有的数组都排好学；