Java快速排序和归并排序区别和实现

快速排序与归并排序的概念：

         快速排序（Quicksort）是对冒泡排序的一种改进。

          快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

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

快速排序与归并排序的区别：

              快速排序的时间复杂度是O (nlogn)，但是快速排序是一种不稳定的排序方法，也就是说当有多个相同的值的时候在排序结束的时候它们的相对位置会发生改变。

               归并排序的时间复杂度是O (nlogn)，但是归并排序是一种稳定的排序方法，即相等的元素顺序不会改变，但是相比于快速排序来说归并要申请的空间更大，消耗空间更多。

快速排序实现方式：

                    快速排序原理基于冒泡排序改进的。设要排序的数组是A[0]....A[N-1],首先任意选取一个数据（通常选取用数组的第一个数）作为关键数据key，然后比key小的数据都放到key的前面，比key大的数据都放在key的后面，这个过程称为一趟快速排序。

                    算法思路：

                                        1>设置两个变量i,j,排序开始的时候,i=low;j = high;(第一趟low=0，high为数组长度N)

                                        2>以第一个数组元素为关键元素，赋值给key，即key = A[0];

                                        3>从j开始像前搜索，找到第一个比key小的数a[j],将a[j]和a[i]交换。

                                        4>从i开始向后搜素，找到第一个比key大的数a[i]，将a[i]和a[j]交换。

                                        5>重复3,4步直到i==j

                                        6>对key左边和右边分别递归调用以上步骤。

                    代码如下:

package sort;

import java.util.Arrays;
import java.util.Scanner;

public class QuickSort {

	public static void main(String[] args) {
		int [] a = {1,11,2,3,5,68,0,1};
		System.out.println("未排序的数组："+Arrays.toString(a));
		if(a.length > 0){
			quickSort(a,0,a.length-1);
		}else{
			System.out.println("空数组不能排序");
		}
		System.out.println("排序后的数组："+Arrays.toString(a));
	}
	public static void quickSort(int[] a,int low,int high){
		if(low > high){
			return;
		}//递归的出口
		int i = low;
		int j = high;
		int key = a[low];
		while(i < j){
			while(a[j] > key && i < j){
					j--;
			}//找到第一个比key小的数
			while(a[i] <= key && i < j){
					i++;
			}//找到第一个比key大的数
			if(i < j){//如果i小于j，交换a[i],a[j]
				int temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}
		int  p = a[i];
		a[i] = a[low];
		a[low] = p;//调整key的位置
		quickSort(a,low,i-1);
		quickSort(a,i+1,high);
	}
}

     归并排序的实现方式：

         归并排序就是利用归并的思想实现的排序方法。而且充分利用了完全二叉树的深度是log2n+1的特性，因此效率比较高。

        基本原理如下：对于给定的一组记录，利用递归与分治技术将数据序列划分成为越来越小的半子表，在对半子表排序，最后再用递归方法将排好序的半子表合并成为越来越大的有序序列。 
经过第一轮比较后得到最小的记录，然后将该记录的位置与第一个记录的位置交换；接着对不包括第一个记录以外的其他记录进行第二次比较，得到最小记录并与第二个位置记录交换；重复该过程，知道进行比较的记录只剩下一个为止。

       实现方式：

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

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

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

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

package sort;
import java.util.Arrays;
public class MergeSort {
	public static void main(String[] args){
		int [] a = {1,11,2,3,5,68,0,1};
		System.out.println("未排序的数组："+Arrays.toString(a));
		if(a.length > 0){
			mergeSort(a,0,a.length-1);
		}else{
			System.out.println("空数组不能排序");
		}
		System.out.println("排序后的数组："+Arrays.toString(a));
	}
	public static void merge(int[]a,int low,int mid,int high){
		int [] mergeArr = new int[high-low+1];//申请一个新空间来保存排序后数组
		int i = low;
		int j = mid + 1;
		int k = 0;
		while(i <= mid && j <= high){
			if(a[i] < a[j]){
				mergeArr[k] = a[i];
				k++;
				i++;
			}else{
				mergeArr[k] = a[j];
				k++;
				j++;
			}
		}
		while(i <= mid){
			mergeArr[k] = a[i];
			k++;
			i++;
		}//把左边剩余的元素导入
		while(j <= high){
			mergeArr[k] = a[j];
			j++;
			k++;
		}//把右边剩余的元素导入
		for(int m = 0;m < mergeArr.length;m++){
			a[m+low] = mergeArr[m];
		}//将新排好序的数组放入元素相应的位置中
	}
	public static void mergeSort(int []a,int low,int high){
		int mid = (low + high) / 2;
		if(low < high){
			mergeSort(a,low,mid);//左
			mergeSort(a,mid+1,high);//右
			merge(a,low,mid,high);//左右合并
		}
	}
}

以上就是我对快速排序算法和归并算法学习的心得，如有不足还多多请各位指教。