归并排序和快速排序

一，归并排序

归并排序算法实现

算法思路：
如果要排序一个数组，我们先从数组中间把数组分成左数组和右数组两部分，分别对左右数组进行排序，然后将排序好的数组合并成结果数组，排序就完成了，最后只需将结果数组复制回原数组即可。

核心思想 ----- 分治思想

分治也即是分而治之，将一个大问题分解为小的子问题来解决。分治算法一般都是用递归来实现的。分治是一种解决问题的处理思想，递归是一种编程技巧。

归并排序分析

1. 稳定排序算法
2. 归并排序的执行效率与原始数据的有序程度无关，其时间复杂度是非常稳定的，不管是最好情况、最坏情况，还是平均情况，时间复杂度都是O(NlogN)。
3. 归并排序有一个缺点，那就是它不是原地排序算法。在进行子数组合并的时候，我们需要临时申请一个数组来暂时存放排好序的数据。因为这个临时空间是可以重复利用的，因此归并排序的空间复杂度为O(n)，最多需要存放n个数据。

具体实现

public class MergeSort {
     

	/**
	 * 归并排序   O(NlogN)
	 * 
	 * 思想：分治
	 * @param oldArray
	 * @param tmpArray
	 * @param left
	 * @param right
	 */
	private static void mergeSort(int[] oldArray,int[] tmpArray,int left,int right) {
     
		if(left < right) {
     
			//中间元素下标
			int center = (left + right)/2;
			//分治左边数组[left , center]
			mergeSort(oldArray, tmpArray, left,center);
			//分治右边数组[center+1 , right]
			mergeSort(oldArray, tmpArray, center+1, right);
			//分开排序后合并成一个新数组在copy会原数组，此时原数组已经有序
			merge(oldArray, tmpArray, left, center+1,right);
			
		}
	}
	
	/**
	 * 排序，合并
	 * @param oldArray
	 * @param tmpArray
	 * @param leftStart
	 * @param rightStart
	 * @param rightEnd
	 */
	private static void merge(int[] oldArray, int[] tmpArray, int leftStart, int rightStart, int rightEnd) {
     
		
		//左数组开始下标
		int leftEnd = rightStart - 1;
		//辅助数组起始下标
		int tmpPos = leftStart;
		//数组元素数量
		int numElements = rightEnd - tmpPos + 1;
		
		//左右数组进行比较,按序放入辅助数组
		while(leftStart <= leftEnd && rightStart <= rightEnd) {
     
			if(oldArray[leftStart] <= oldArray[rightStart]) {
     
				tmpArray[tmpPos++] = oldArray[leftStart++];
			}else {
     
				tmpArray[tmpPos++] = oldArray[rightStart++];
			}
		}
		
		//判断子数组是否还有元素，有则拷贝到 tmp 后面
		while(leftStart <= leftEnd) {
     
			tmpArray[tmpPos++] = oldArray[leftStart++];
		}
		
		//判断子数组是否还有元素，有则拷贝到 tmp 后面
		while(rightStart <= rightEnd) {
     
			tmpArray[tmpPos++] = oldArray[rightStart++];
		}
		
		//复制辅助数组回原数组
		for(int i = 0;i<numElements;i++,rightEnd--) {
     
			oldArray[rightEnd] = tmpArray[rightEnd];
		}
	}


	public static void main(String[] args) {
     
		// TODO Auto-generated method stub
		int[] a = {
     1,8,2,6,4,2,3,8,4,6,10,12,45,21,31};
		int[] tmpArray = new int[a.length];
		mergeSort(a, tmpArray, 0, a.length-1);
		for(int i = 0;i<a.length;i++) {
     
			System.out.print(a[i]+"\t");
		}
		
	}

}

结果：

二，快速排序

算法思路：
随便选取一项（一般是中间值），然后形成三个组，小于被选项组，大于被选项组合等于被选项组，递归的对小于被选项组，大于被选项组进行排序，然后合并这三个组。

核心思想：------- 分治思想

算法分析：

1. 快速排序是一个原地排序算法，是一个不稳定的排序算法，因为其在数据交换过程中可能会改变相等元素的原始位置。
2. 平均时间复杂度O(NlogN) ,最坏时间复杂度O(N^2)
3. 如果快速排序每次都将数据分成相等的两部分，则快排的时间复杂度和归并排序相同，也是O(nlogn)，但这种情况是很难实现的。如果数据原来已经是有序的，则每次的分区都是不均等的，我们需要进行 n 次分区才能完成整个排序，此时快排的时间复杂度就退化成了O(n^2)

public class QuickSort {
     

	/**
	 * 快速排序   O(NlogN)
	 * @param list
	 */
	private static void quickSort(ArrayList<Integer> list) {
     
		
		if(list.size()>1) {
     
			
			ArrayList<Integer> smallerlist = new ArrayList<>();
			ArrayList<Integer> centerList = new ArrayList<>();
			ArrayList<Integer> largeList = new ArrayList<>();
			
			//中间元素
			Integer center = list.get(list.size()/2);
			
			//分类
			for(Integer i : list) {
     
				if(i < center) {
     
					//比中间元素小
					smallerlist.add(i);
				}else if (i > center) {
     
					//比中间元素大
					largeList.add(i);
				}else {
     
					//与中间元素相等
					centerList.add(i);
				}
			}
			
			//分组排序
			quickSort(smallerlist);
			quickSort(largeList);
			
			//清空
			list.clear();
			//合并
			list.addAll(smallerlist);
			list.addAll(centerList);
			list.addAll(largeList);
		}
	}
	
	
	public static void main(String[] args) {
     
		int[] a = {
     1,8,2,6,4,2,3,8,4,6,10,12,45,21,31};
		
		ArrayList<Integer> list = new ArrayList<>();
		
		for(int i = 0;i<a.length;i++) {
     
			list.add(a[i]);
		}
		
		quickSort(list);
		
		for(Integer integer : list) {
     
			System.out.println(integer+"\t");
		}
	}
}

结果：