【Java】排序方法--归并排序

基本思想

同选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n*logn）的时间复杂度。代价是需要额外的内存空间。

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

算法描述：

算法诗：

将数组分为两半

对左半部分排序

对右半部分排序

合并左右两部分

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

第四步：重复步骤3直到某一指针超出序列尾，将另一序列剩下的所有元素直接复制到合并序列尾

动态图解释（来源网络）：

 

实现方法接口：

方案一：

常规的递归思想：

package 排序方法;

import java.util.*;

public class Merge{
	public static void MergeSort(int[] arr) {
		sort(arr, 0, arr.length - 1);
	}
	public static void sort(int[] arr, int L, int R) {
		if (L == R) {
			return;
		}
		int mid = (R + L) >> 1;
		sort(arr, L, mid);
		sort(arr, mid + 1, R);
		merge(arr, L, mid, R);
	}
	public static void merge(int[] arr, int L, int mid, int R) {
		int[] temp = new int[R - L + 1];
		int i = 0;
		int p1 = L;
		int p2 = mid + 1;
		while (p1 <= mid && p2 <= R) {// 比较左右两部分的元素，哪个小，把那个元素填入temp中
			temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		// 上面的循环退出后，把剩余的元素依次填入到temp中
		// 以下两个while只有一个会执行
		while (p1 <= mid) {//看是否有剩余元素
			temp[i++] = arr[p1++];
		}
		while (p2 <= R) {
			temp[i++] = arr[p2++];
		}
		// 把最终的排序的结果复制给原数组
		for (i = 0; i < temp.length; i++) {
			arr[L + i] = temp[i];
		}
	}

	public static void main(String[] args) {
		int[] a = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
		MergeSort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}
}

输出如图：

方案二：

先建立从Collection接口，再通过调用接口来实现：

import java.util.Collections;
import java.util.List;

public class Collection {

    public static void sort(List list) {
        int l = 0;
        int r = list.size () - 1;
        //归并
        devide (list, l, r);

    }

    /**
     * 归：分治
     */
    private static void devide(List list, int left, int right) {

        int mid = (left + right) / 2;//计算中值索引
        // 归
        if (left < right) {
            devide (list, left, mid);
            devide (list, mid + 1, right);
            merge (list, left, mid, mid + 1, right);
        } else {
            //并

            merge (list, left, mid, mid + 1, right);
        }


    }

    /**
     * @param list
     * @param left
     * @param mid
     * @param i
     * @param right
     */

    private static void merge(List list, int left, int mid, int i, int right) {
        int index = left;
        Object[] temp = new Object[list.size ()];
        int ls = left, le = mid;//左边的起始索引和结束索引；
        int rs = i, re = right;//右边的起始索引和结束索引；

        //至少把一边的所有数组元素按顺序放入临时数组；
        while (ls <= le && rs <= re) {
            Comparable o1 = (Comparable) list.get (ls);
            Comparable o2 = (Comparable) list.get (rs);
            if (o1.compareTo (o2) == -1) {
                temp[index] = o1;
                ls++;
            } else {
                temp[index] = o2;
                rs++;
            }

            index++;
        }
        //判断左边是否有剩余元素
        if (ls <= le) {
            for (int j = ls; j <= le; j++) {

                temp[index++] = list.get (j);

            }
        }
        //判断右边是否有剩余元素
        if (rs <= re) {
            for (int j = rs; j <= re; j++) {
                temp[index++] = list.get (j);
            }
        }

        for (int j = left; j <= right; j++) {
            list.set (j, temp[j]);
        }
    }
}

Test类：

public class TestColections {
    public static void main(String[] args) {
    @Test
        public void test3(){
            List s = new ArrayList ();
            s.add (new Student (1001, "路飞", "M"));
            s.add (new Student (1030, "明哥", "M"));
            s.add (new Student (1002, "娜美", "W"));
            s.add (new Student (1010, "卡二", "M"));
            s.add (new Student (1008, "女帝", "W"));
            edu.xalead.Collection.sort(s);

            System.out.println (s);
        }
    }
}

Student类：

/**
 * 调用一个接口，接口的对象是对Student进行比较，
 * 比较是比较code，而不是其他的东西，所以要调用。
 */
public class Student implements Comparable{

    private int Code;
    private String Name;
    private String Sex;

    public int getCode() {
        return Code;
    }

    public void setCode(int code) {
        Code = code;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public String getSex() {
        return Sex;
    }

    public void setSex(String sex) {
        Sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "Code=" + Code +
                ", Name='" + Name + '\'' +
                ", Sex='" + Sex + '\'' +
                '}';
    }


    public Student(int code , String name, String sex) {
        this.Code = code;
        this.Name = name;
        this.Sex = sex;
    }


    /**
     *
     *
     *这是一个接口，对应于Comparable,也就是方法的接口，Student要进行比较是
     *比较它的code，所以要调用这个接口来比较。
     *
     * */
    public int compareTo(Object o){

        if(o instanceof Student){
            Student s = (Student) o;
            if(this.getCode () > s.getCode ()) return 1;
            else if(this.getCode () < s.getCode ()) return -1;
            return 0;

        }
        throw new RuntimeException("类型不对，无法匹配");
    }

}

输出结果：

Student{Code=1001, Name='路飞', Sex='M'},

Student{Code=1002, Name='娜美', Sex='W'},

Student{Code=1008, Name='女帝', Sex='W'},

Student{Code=1010, Name='卡二', Sex='M'},

Student{Code=1030, Name='明哥', Sex='M'}