java算法实现（一）排序算法

1. 选择排序

/**
 * 选择排序
 * @author DreamingTheStars
 */
public class SelectSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}
}

2. 插入排序

/**
 * 插入排序
 * @author DreamingTheStars
 */
public class InsertSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		for(int i=1;i<arr.length;i++) {
			int temp=arr[i];
			int j;
			for(j=i-1;j>=0;j--) {
				if(arr[j]>temp) {
					arr[j+1]=arr[j];
				}else {
					break;
				}
			}
			arr[j+1]=temp;	
		}
	}

3. 冒泡排序

/**
 * 冒泡排序
 * @author DreamingTheStars
 */
public class BubbleSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr.length-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
}

4. 归并排序

/**
 * 二路归并排序
 * @author DreamingTheStars
 */
public class MergeSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		mergeSort(arr,0,arr.length-1);
	}	
	/**
	 * 
	 * @param arr 输入的数组
	 * @param start 开始部分
	 * @param end 结束部分
	 */
	public static void mergeSort(int[] arr,int start,int end) {
		if(start<end) {
			int center=(start+end)/2;
			mergeSort(arr,start,center);
			mergeSort(arr,center+1,end);
			merge(arr,start,end);
		}
	}
	
	public static void merge(int[] arr,int start,int end) {
		int center=(start+end)/2;
		int p1=start;
		int p2=center+1;
		int[] temp=new int[end-start+1];
		int pTemp=0;
		while(p1<=center&&p2<=end) {
			if(arr[p1]<=arr[p2]) {
				temp[pTemp++]=arr[p1++];
			}
			else {
				temp[pTemp++]=arr[p2++];
			}
		}
		while(p1<=center) {
			temp[pTemp++]=arr[p1++];
		}
		while(p2<=end) {
			temp[pTemp++]=arr[p2++];
		}	
		for(int i=0;i<temp.length;i++) {
			arr[start+i]=temp[i];
		}
	}

5. 快速排序

/**
 * 快速排序
 * @author DreamingTheStars
 */
public class QuickSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		if(arr.length==0) {
			return;
		}
		quickSort(arr,0,arr.length-1);
	}
	
	public static void quickSort(int arr[],int start,int end) {
		//找到支点，并将其放在数组的最后。不推荐直接选第一个或者最后一个元素作为支点，因为这样在原本有序的数组中十分低效。推荐选则中间元素或者第一个元素、最后一个元素、中间元素的中位数作为支点，这里用第二种方法。
		int pivot=median(arr,start,end);
		change(arr,end,pivot);
		pivot=end;

		//将小元素移到数组前面，大元素移到数组后面
		int p1=start;
		int p2=end-1;
		while(p1<p2) {
			//从前找到一个大于支点的元素
			while(p1<p2&&arr[p1]<=arr[pivot]) {
				p1++;
			}
			//从后找到一个小于支点的元素
			while(p1<p2&&arr[p2]>=arr[pivot]) {
				p2--;
			}
			//交换两者位置
			if(p1<p2) {
				change(arr,p1,p2);
			}
		}
		//将支点移动到大小元素之间
		change(arr,pivot,p1);
		pivot=p1;
		
		//如果子数组个数大于1，则对子数组进行快排
		if(pivot-start>1) {
			quickSort(arr, start, pivot-1);
		}
		if(end-pivot>1) {
			quickSort(arr, pivot+1, end);
		}
	}
	
	/**
	 * 交换arr[i]与arr[j]的位置
	 * @param arr
	 * @param i
	 * @param j
	 */
	public static void change(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	
	/**
	 * 返回数组中开始位置，结束位置，中间位置三个数的中位数的下标
	 * @param arr 输入的数组
	 * @param start 数组开始位置
	 * @param end 数组结束位置
	 * @return 中位数下标
	 */
	public static int median(int[] arr,int start,int end) {
		int centerI=(end-start)/2;
		if((arr[centerI]-arr[start])*(arr[end]-arr[start])<=0) {
			return start;
		}
		else if((arr[centerI]-arr[end])*(arr[start]-arr[end])<=0) {
			return end;
		}
		else {
			return centerI;
		}
	}
}

6. 希尔排序

/**
 * 希尔排序
 * @author DreamingTheStars
 */
public class ShellSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		for(int gap=arr.length/2;gap>=1;gap=gap/2) {
			for(int i=gap;i<arr.length;i++) {
				int temp=arr[i];
				int j;
				for(j=i-gap;j>=0;j-=gap) {
					if(arr[j]>temp) {
						arr[j+gap]=arr[j];
					}else {
						break;
					}
				}
				arr[j+gap]=temp;	
			}
		}
	}
}

7. 堆排序

/**
 * 插入排序
 * @author DreamingTheStars
 */
public class HeapSort {
	/**
	 * @param arr 输入的数组
	 */
	public static void sort(int[] arr) {
		buildHeap(arr);
		for(int i=0;i<arr.length;i++) {
			arr[arr.length-i-1]=remove(arr,arr.length-i);
		}
	}

	/**
	 * 将传入的数组构建成为一个小顶堆
	 * @param arr 传入的数组
	 */
	public static void buildHeap(int[] arr) {
		for(int i=(arr.length-1)/2;i>=0;i--) {
			percolateDown(arr,i,arr.length);
		}
	}
	
	/**
	 * 移除堆顶元素
	 * @param arr
	 * @return 返回移除的值
	 */
	public static int remove(int[] arr,int length) {
		int re=arr[0];
		arr[0]=arr[length-1];
		percolateDown(arr,0, length-1);
		return re;
	}
	
	/**
	 * 向下过滤
	 */
	public static void percolateDown(int[] arr,int i,int length) {
		while((i+1)*2-1<length) {
			int child;
			if((i+1)*2<length) {
				child=arr[(i+1)*2-1]<arr[(i+1)*2]?(i+1)*2-1:(i+1)*2;
			}
			else {
				child=(i+1)*2-1;
			}
			if(arr[i]>arr[child]) {
				int temp=arr[i];
				arr[i]=arr[child];
				arr[child]=temp;
				i=child;
			}
			else {
				break;
			}
		}
	}
}