排序算法

1、插入排序

	public static void insert(int[] arr) {
		//插入排序
		int j,temp;
		for(int i=1;i<arr.length;i++) {
			temp = arr[i];
			for( j=i; j>0&&temp>arr[j-1] ;j--) 
				arr[j]=arr[j-1];
			arr[j] = temp;
		}
	}

2、希尔排序

	public static void shell(int []arr) {
		//希尔排序
		for(int gap=arr.length/2;gap>0;gap/=2) 
			for(int i=gap;i<arr.length;i++)
				for(int j= i-gap;j>=0&&arr[j]<arr[j+gap];j-=gap)
					swap(arr,j,j+gap);
	}

3、快速排序

	public static void quick(int[] arr,int left,int right) {
		//快速排序
		int pointer=arr[left],l=left,r=right;
		while(l<r) {
			while(l<r&&pointer>arr[r])
				r--;
			arr[l] = arr[r];
			
			while(l<r&&arr[l]>pointer)
				l++;
			arr[r] = arr[l];
		}
		arr[l]=pointer;
		if(left<l)
			quick(arr,left,l-1);
		if(right>l)
			quick(arr,l+1,right);
	}

4、二路归并排序

	public static void merge(int arr[],int n) {
		int[] p =new int[n];
		if(p==null)
			return;
		mergeSort(arr,0,n-1,p);
	}

	public static void mergeSort(int arr[],int left,int right,int temp[]) {
		if(left<right) {
			int mid = (left+right)/2;
			mergeSort(arr,left,mid,temp);
			mergeSort(arr,mid+1,right,temp);
			mergeArray(arr,left,mid,right,temp);
			
		}
	}

	//合并两个有序数列
	public static void mergeArray(int[] arr,int left,int mid,int right,int temp[]) {
		int i =left,j=mid+1,m=mid,n=right;
		int k =0;
		while(i<=m && j<=n)
			if(arr[i]>=arr[j])
				temp[k++]=arr[i++];
			else
				temp[k++]=arr[j++];
		while(i<=m)
			temp[k++]=arr[i++];
		while(j<=n)
			temp[k++]=arr[j++];
		for(int ii=0;ii<k;ii++)
			arr[left+ii]=temp[ii];
	}

5、堆排序

	public static void heap(int[] arr) {
		heapBuild(arr);
		int len=arr.length;
		for(;len>1;len--) {
			sort.swap(arr,0,len-1);
			System.out.print(arr[len-1]+"	");
			heapAdjust(arr,0,len-1);
		}
		System.out.print(arr[len-1]+"	");
		
	}

	public static void heapBuild(int[] arr) {
		for(int ii =0;ii<arr.length;ii++) {
			int i = ii;
			int fatherI = (i-1)/2;
			while(arr[i]<arr[fatherI]) {
				sort.swap(arr,i,fatherI);
				i=fatherI;
				fatherI=(i-1)/2;
			}
		}
	}// 建堆是自下而上进行的

	public static void heapAdjust(int[] arr,int i,int len) {
		int left = 2*i+1,right=2*i+2;
		while(left<len) {
			int bigIndex= 
					right<len ? ( arr[left]>arr[right]? right:left ):left;
			if(arr[i]<=arr[bigIndex])
				break;
			else {
				sort.swap(arr, i, bigIndex);
				i=bigIndex;
				left = 2*i+1;
				right=2*i+2;
			}
			
		}
	}//堆调整是自上而下进行的