算法与数据结构-排序(2)

归并排序
如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。

public static void merger(int[] a,int left,int mid,int right) {
		int[] temp=new int[a.length];
		int p1=left,p2=mid+1,k=left;
		while(p1<=mid&&p2<=right) {
			if(a[p1]<=a[p2]) {
				temp[k++]=a[p1++];
			}else {
				temp[k++]=a[p2++];
			}
		}
		while(p1<=mid) {
			temp[k++]=a[p1++];
		}
		while(p2<=right) {
			temp[k++]=a[p2++];
		}
		 //复制回原素组
        for (int i = left; i <=right; i++) 
            a[i]=temp[i];
    }
	
	public static void sort(int[] a,int left,int right) {
		int mid=(left+right)/2;
		if(left>=right)
			return;
		sort(a,left,mid);
		sort(a,mid+1,right);
		merger(a, left, mid, right);
	}

快速排序

快排的思想是这样的：如果要排序数组中下标从 p 到 r 之间的一组数据，我们选择 p 到 r
之间的任意一个数据作为 pivot（分区点）。
我们遍历 p 到 r 之间的数据，将小于 pivot 的放到左边，将大于 pivot 的放到右边，将
pivot 放到中间。经过这一步骤之后，数组 p 到 r 之间的数据就被分成了三个部分，前面
p 到 q-1 之间都是小于 pivot 的，中间是 pivot，后面的 q+1 到 r 之间是大于 pivot 的。
根据分治、递归的处理思想，我们可以用递归排序下标从 p 到 q-1 之间的数据和下标从
q+1 到 r 之间的数据，直到区间缩小为 1，就说明所有的数据都有序了。
递推公式
sort(p,r)=sort(p,q-1)+sort(q+1,r)
终止条件p>=r
伪代码
伪代码：// 快速排序，A 是数组，n 表示数组的大小
quick_sort(A, n) {
quick_sort_c(A, 0, n-1)
}
// 快速排序递归函数，p,r 为下标
quick_sort_c(A, p, r) {
if p >= r then return
q = partition(A, p, r) // 获取分区点
quick_sort_c(A, p, q-1)
quick_sort_c(A, q+1, r)
partition(A, p, r) {
pivot := A[r]
i := p
for j := p to r-1 do {
if A[j] < pivot {
swap A[i] with A[j]
i := i+1
}
}
swap A[i] with A[r]
return i
注意：
快速排序不是稳定的排序算法

public static void sort(int[] array,int l,int r) {
	if(array.length<=1) {
		return;
	}
	if(l>=r) {
		return;
	}
	int index=partition(array,l,r);
	sort(array,l,index-1);
	sort(array,index+1,r);
}

private static int partition(int[] array, int l, int r) {
	// TODO Auto-generated method stub
	int key=array[l];
	while(l<r) {
		while(array[r]>=key&&r>l) {
			r--;
		}
		array[l]=array[r];
		while(array[l]<=key&&r>l) {
			l++;
		}
		array[r]=array[l];
	}
	array[r]=key;

	return r;
}