排序算法：快速排序，归并排序

快速排序和归并排序都是nlogn时间复杂度的排序算法

1、快速排序

思路：

    数组取标杆pivot，将比pivot小的元素放在pivot左边，大于pivot的元素放在pivot右边

    依次对左边和右边的子数组快排

    最终达到整个数组有序

public class QuickSort {
	
	@Test
	public void test() {
		int[] nums = {2,1,5,3,4};
		sort(nums);
		System.out.println(Arrays.toString(nums));
	}

	/**
	 * 快速排序，升序
	 * 数组取标杆pivot，将比pivot小的元素放在pivot左边，大于pivot的元素放在pivot右边
	 * 依次对左边和右边的子数组快排
	 * 最终达到整个数组有序
	 * @param nums
	 */
	public void sort(int[] nums) {
		quickSort(nums, 0, nums.length-1);
	}
	
	/**
	 * 将数组nums的[being, end]的元素进行快排，升序
	 * @param nums
	 * @param begin
	 * @param end
	 */
	private void quickSort(int[] nums, int begin, int end) {
		if(begin>=end) {
			return;
		}
		
		int pivot = partition(nums, begin, end);
		quickSort(nums, begin, pivot-1);
		quickSort(nums, pivot+1, end);
	}
	
	private int partition(int[] nums, int begin, int end) {
		int pivot = end;
		//下标count左边的元素都是比pivot小的
		//count指向的元素比pivot大，用于标记要交换的位置
		int count = begin;
		for(int i=begin; i<end; i++) {
			if(nums[i]<nums[pivot]) {
				swap(nums, i, count);
				count++;
			}
		}
		swap(nums, pivot, count);
		return count;
	}
	
	private void swap(int[] nums, int i, int j) {
		int tmp = nums[i];
		nums[i] = nums[j];
		nums[j] = tmp;
	}
	
}

2、归并排序

思路：

    把长度为n的数组分成两个长度为n/2的子数组

    对两个子数组进行归并排序

    把两个排序好的子数组合并成一个有序的数组

public class MergeSort {

	@Test
	public void test() {
		int[] nums = {2,1,5,3,4};
		sort(nums);
		System.out.println(Arrays.toString(nums));
	}
	
	/**
	 * 归并排序，升序
	 * 把长度为n的数组分成两个长度为n/2的子数组
	 * 对两个子数组进行归并排序
	 * 把两个排序好的子数组合并成一个有序的数组
	 * @param nums
	 */
	public void sort(int[] nums) {
		mergeSort(nums, 0, nums.length-1);
	}
	
	private void mergeSort(int[] nums, int begin, int end) {
		if(begin>=end) {
			return;
		}
		
		int mid = (begin+end)>>1;
		mergeSort(nums, begin, mid);
		mergeSort(nums, mid+1, end);
		merge(nums, begin, mid, end);
	}

	/**
	 * 将有序的nums[begin, mid]和有序的nums[mid+1, end]合并起来
	 * 使得nums[begin, end]有序
	 * 开辟了一个新数组，使用双指针,将数据依次填入新数组中，再将新数组拷贝给nums
	 * @param nums
	 * @param begin
	 * @param mid
	 * @param end
	 */
	private void merge(int[] nums, int begin, int mid, int end) {
		int[] tmpArray = new int[end-begin+1];
		int index = 0;
		
		int i = begin;
		int j = mid+1;
		while(i<=mid&&j<=end) {
			tmpArray[index++] = nums[i]<nums[j] ? nums[i++] : nums[j++];
		}
		while(i<=mid) {
			tmpArray[index++] = nums[i++];
		}
		while(j<=end) {
			tmpArray[index++] = nums[j++];
		}
		
		System.arraycopy(tmpArray, 0, nums, begin, tmpArray.length);
	}
	
}