归并排序

归并排序

1.将两个有序序列归并成一个有序序列

2.将带排序数组，通过递归调整成左右两个有序序列，在调用归并算法，将其归并成一个有序序列，完成排序

Merg.java

package com.gxf.merg;

/**
 * 归并排序
 * 初始状态，将数组看成n个单独有序的序列，两两合并成一个有序序列，把最后两个序列合并
 * 用一个方法归并两个有序序列
 * 用递归将数组分成两个有序序列，在对两个序列进行归并排序，得到有序序列
 * @author xiangfei
 *
 */
public class Merg {
    public Rec rec = new Rec();
    /**
     * 将有序序列[start, middel][middle + 1, end]归并成一个有序序列，放到rec1数组中
     * 分别用三个指针i,j,k指向两个区间和rec1数组
     * 将rec[i]和rec[j]中较小的元素放到rec1[k]中
     * 直到其中一个区间结束，在把剩下元素放到rec1[]中
     * @param rec
     * @param start
     * @param middle
     * @param end
     * @param rec1
     */
    public void merg(Rec rec[], int start, int middle, int end, Rec rec1[]){
        int first = start;
        int second = middle + 1;
        int dst = start;//三个指针
        
        while(first <= middle && second <= end){
            if(rec[first].key < rec[second].key) 
                rec1[dst++].key = rec[first++].key;
            else
                rec1[dst++].key = rec[second++].key;
        }//比较两个序列中的值，将较小的放到rec1[]中。直到其中一个全部放到rec1[]中
        while(first <= middle)
            rec1[dst++].key = rec[first++].key;//如果第一区间没有完全移动到rec1中
        while(second <= end)
            rec1[dst++].key = rec[second++].key;//如果第二个区间还有内容，将剩下的移动到rec1中
//        for(int i = start; i < rec1.length ; i++){
//            System.out.print(rec1[i].key + " ");
//        }
//        System.out.println();
    }
    
    /**
     * 将rec[]分成左右两个区间，通过递归将其分为左右两个有序区间，调用一次归并将其合并成一个有序序列
     * rec[]排好序放到rec1[]中
     * 如果只有一个元素，将rec放到rec1中
     * @param rec
     * @param start
     * @param end
     * @param rec1
     */
    public void mergSort(Rec rec[], int start, int end, Rec rec1[]){
        Rec rec2[] = this.rec.getNewArray(end  + 1);//这里为毛不是end - start + 1?
        if(start == end){
            rec1[start].key = rec[start].key;
        }
        else{
            int middle = (start + end) / 2;
            mergSort(rec, start, middle, rec2);
            mergSort(rec, middle + 1, end, rec2);//将左右区间调整为有序
            merg(rec2, start, middle, end, rec1);
        }
    }
    
    /**
     * 向类调用者提供一个接口方便调用
     * @param rec
     */
    public void mergSort(Rec rec[]){
        Rec result[] = this.rec.getNewArray(rec.length);
        mergSort(rec, 0, rec.length - 1, result);
        System.arraycopy(result, 0, rec, 0, result.length);
    }
}

Rec.java

package com.gxf.merg;

/**
 * 将关键字封装一下
 * @author xiangfei
 *
 */
public class Rec {
    int key;
    
    public Rec(int key){
        this.key = key;
    }
    public Rec(){
        
    }
    
    /**
     * 根据整型数组构造一个Rec[]数组
     * @param array
     * @return
     */
    public Rec[] getRecArray(int array[]){
        Rec rec[] = new Rec[array.length];
        for(int i = 0; i < array.length; i++){
            rec[i] = new Rec(array[i]);
        }
        
        return rec;
    }
    public void showArray(Rec rec[]){
        for(int i = 0; i < rec.length ; i++){
            
            System.out.print(rec[i].key + " ");
        }
        System.out.println();
    }
    public Rec[] getNewArray(int size){
        Rec array[] = new Rec[size];//数组中每个对象都是null,这里需要注意
        for(int i = 0; i < size; i++){
            array[i] = new Rec();
        }
        return array;
    }
}

Test.java

package com.gxf.merg;



public class Test {
    public static void main(String args[]){
        Merg mergSort = new Merg();
        Rec rec = new Rec();
        int array[] = new int[]{40, 32, 1, 34, 54, 5, 6};
        Rec array_test[] = rec.getRecArray(array);
        System.out.println("归并排序之前:");
        rec.showArray(array_test);
        mergSort.mergSort(array_test);
        System.out.println("归并排序之后：");
        rec.showArray(array_test);
    }
}