排序算法复习笔记

package com.Test.Sort;
/*
 * author:Tammy Pi
 * function:排序算法总结
 */
public class SortTest {

	//冒泡排序
	public static int[] sort1(int[] a){
		
		for(int i=0;i<a.length-1;i++){
			
			for(int j=0;j<a.length-1-i;j++){
				
				if(a[j]>a[j+1]){
					
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
		
		return a;
	}
	
	//插入排序
	public static int[] sort2(int[] a){
		
		for(int i=0;i<a.length;i++){
			
			int t = a[i];
			int j;
			for(j=i-1;j>=0;j--){
				
				if(a[j]>t){
					
					a[j+1] = a[j];
				}else{
					
					break;
				}
			}
			a[j+1] = t;
		}
		
		return a;
	}
	
	//归并排序
	public static int[] merge(int[] a,int i,int p,int j){
		
		int[] q = new int[j-i+1];
		int m=i-1,n=p,index=-1;
		while(m+1<=p&&n+1<=j){
			
			if(a[m+1]<=a[n+1]){
				
				q[++index] = a[++m];
			}else{
				
				q[++index] = a[++n];
			}
		}
		while((m+1)<=p){
			
			q[++index] = a[++m];
		}
		while((n+1)<=j){
			
			q[++index] = a[++n];
		}
		
		//写入a中
		for(int k=i;k<=j;k++){
			
			a[k] = q[k-i];
		}
		return a;
	}
	public static int[] mergeSort(int[] a,int i,int j){
		
		if(i>=0&&j>=0&&i<j){
			
			int p = (i+j)/2;
			a = mergeSort(a,i,p);
			a = mergeSort(a,p+1,j);
			a = merge(a,i,p,j);
		}
		return a;
	}
	
	//快速排序
	public static int partion(int[] a,int i,int j){
		
		int m = i,n = j+1,x = a[i];
		while(true){
			
			while(a[++m]<x&&m<j);
			while(a[--n]>x);
			if(m>=n){
				
				break;
			}
			int temp = a[m];
			a[m] = a[n];
			a[n] = temp;
		}
		a[i] = a[n];
		a[n] = x;
		return n;
	}
	//快速排序
	public static int[] quickSort(int[] a,int i,int j){
		
		if(i<j){
			
			int p = partion(a,i,j);
			a = quickSort(a,i,p-1);
			a = quickSort(a,p+1,j);
		}
		return a;
	}
	
	public static void main(String[] args){
		
		int[] a1 = {6,6,9,9,3,2,1,4};
		//a1 = sort1(a1);
		//a1 = sort2(a1);
		//a1 = mergeSort(a1,0,4);
		a1 = quickSort(a1,0,a1.length-1);
		for(int i=0;i<a1.length;i++){
			
			System.out.print(a1[i]+" ");
		}
		System.out.println();
	}
}

以上复习了四种排序方法，分别是冒泡排序、插入排序、归并排序和快速排序，下面对这几种排序算法做一个总结和说明。

冒泡排序：即对于n各数，进行n-1次比较（最后一次比较式针对两个数），第一次比较是0<->1,1<->2,n-2<->n-1,以后的比较以此类推。时间复杂度是n^2，属于稳定的排序。

插入排序：即对于第i个数，查看其前面的i-1个数，如果有比它大的，则依次后移，直到找到小于等于它的数，再将此数插入到空出的位置上。时间复杂度为n^2，属于稳定的排序。

归并排序：即不断的对数组进行二分，再将有序的小集合组装成为大集合。时间复杂度为nlog(n)，属于稳定的排序。

快速排序：即不断的找一个点，使得这个点左边的数都小于这个点，这个点右边的数都大于这个点。时间复杂度为nlog(n)是不稳定的排序。最差的时间复杂度可能是n^2。