归并排序+快速排序算法

一、归并排序算法的原理

归并排序是java对象常用的排序方法，其思想使用递归的原理，首先将数组划分为几段已经排序好的子部分，然后两两进行比较，子部分的第一位与第一位比较，谁小将谁放入新数组的第一位，然后取小的子段的第二位与之前较大的第一位比较，以此类推，重复操作，如果最后某个子段较长剩下没有比较的数，则直接放入新的数组。

下面展示一些 归并排序代码片。

//归并排序法
package arraylist;

public class MergeSort {

	public static void main(String[] args) {
		int[] arr= {2,5,8,9,1,3,4};
		sort(arr,0,arr.length-1);
		print(arr);	
	}	
		public static void sort(int[] arr,int left,int right) {
			if (left==right) return ;
			//分成两半
			int mid=left+(right-left)/2;//为了避免数组较大超出区间
			//左边排序
			sort(arr,left,mid);
			
			//右边排序
			sort(arr,mid+1,right);
			
			merge(arr,left,mid+1,right);
					
		}
	//定义merge方法
		static void merge(int[] arr, int leftPtr,int rightPtr,int rightBounder) {
			int mid=rightPtr-1;
			int temp[]=new int[rightBounder-leftPtr+1];//定义一个新的数组来存放新的排序结果
			
			int i=leftPtr,j=rightPtr,k=0;
			while(i<=mid && j<=rightBounder) {
//				if(arr[i]<=arr[j]) {
//					temp[k++]=arr[i++];
//				}else {
//					temp[k++]=arr[j++];
//				}
				temp[k++]=arr[i]<=arr[j] ? arr[i++]:arr[j++]; 
				
			}
			while(i<=mid) {
				temp[k]=arr[i];
				i++;
				k++;
			}
			while(j<=rightBounder) {
				temp[k++]=arr[j++];
			}
			
			//print(temp);
			for(int m=0;m<temp.length;m++) {
				arr[leftPtr+m]=temp[m];
			}
		}
						
		static void print(int[] arr) {
			for(int i1=0;i1<arr.length;i1++) {
				System.out.print(arr[i1]+"  ");
			}
			
		} 	
}

归并排序分为几个子部分，总共分为***logn***部分，每个部分计算复杂度为***n***，所以整体的时间复杂度为***O（nlogn）***,空间复杂度为***O（n）***,算法是稳定的。

二、快速排序算法的原理

快速排序是首先取定一个数作为轴，将大于轴和小于轴的数分到两边，这个轴的位置不变，然后再取一个数作为轴这样迭代即可。

下面展示 快速排序代码片。

//快速排序法
package arraylist;

public class QuickSort {
	public static void main(String[] args) {
		int[] arr= {7,3,2,6,8,9,6,5,4,6};
		sort(arr,0,arr.length-1);
		print(arr);
		
	}

	public static void sort(int[] arr,int left,int right) {
		if (left>=right) return ;
		
		int mid=partition(arr,left,right);
		sort(arr,left,mid-1);
		sort(arr,mid+1,right);
		
	}
	static int partition(int[] arr,int leftBound,int rightBound) {
		int pivot=arr[rightBound];
		int left=leftBound;
		int right=rightBound-1;
		
		while(left<=right) {//保证只有两个数都可以进行比较，
			while(left<=right && arr[left]<=pivot) left++;
			while(left<=right && arr[right]>pivot) right--;
			if(left<right) swap(arr,left,right);//循环遍历过程中如果大于轴的时候跳出，小于轴的也跳出，将两个位置的值进行交换。
		//	System.out.println("left:"+left+"right:"+right);
		}
		swap(arr,left,rightBound);
		return left;
	}
	
	static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;	
		
	}
				
	static void print(int[] arr) {
		for(int i1=0;i1<arr.length;i1++) {
			System.out.print(arr[i1]+"  ");
		}
		
	} 
}

快速排序也是分为几个子部分，总共分为***n***个***logn***部分，所以整体的时间复杂度为***O（nlogn）***,空间复杂度为***O（logn）***,算法是不稳定的。