Java排序算法

排序算法

1. 冒泡排序

/**
	 * 功能：原理
	 * （1）比较相邻的元素。如果第一个比第二个大，就交换他们两个；
	 * （2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数；
	 * （3）针对所有的元素重复以上的步骤，除了最后一个；
	 * （4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。<br/>
	 */
	public static int[] maopao(int[] arr){
		for (int i = arr.length-1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		return arr;
	}

2. 选择排序

/**
	 * 功能：原理：
	 * 选择排序是对冒泡排序的改进，因为冒泡排序每次比较后都要互换两个元素位置，而互换的过程会有几次赋值，特别耗费时间。
	 * 选择排序的思路： 是每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完<br/>
	 */
	public static int[] select(int[] arr){
		for (int i = 0; i < arr.length-1; 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;
				}
			}
		}
		return arr;
	}

3. 插入排序

/**
	 * 功能：原理：
	 * 插入排序的原理和打牌的时候理牌比较像，就是每步将一个待排序的纪录，将其插入前面已经排序的序列的适当位置上，直到全部插入完为止。<br/>
	 */
	public static int[] insert(int[] arr){
		for (int i = 1; i < arr.length; i++) {
			for (int j = i-1; j >= 0; j--) {
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}else{
					break;
				}
			}
		}
		return arr;
	}

4.快速排序

/**
	 * 功能：快速排序（Quicksort）是对冒泡排序的一种改进
	 * 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。<br/>
	 * 算法步骤：一趟快速排序的算法是：
	 * 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
	 * 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
	 * 3）从j开始向前搜索，即由后开始向前搜索（j -- ），找到第一个小于key的值A[j]，A[i]与A[j]交换； 
	 * 4）从i开始向后搜索，即由前开始向后搜索（i ++ ），找到第一个大于key的A[i]，A[i]与A[j]交换； 
	 * 5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。
	 */
	public static void quick(int[] arr){
		quick(arr,0,arr.length-1);
	}
	public static void quick(int[] arr,int lo,int hi){
		if(lo<hi){
			int index = partition(arr,lo,hi);
			quick(arr,lo,index-1);
			quick(arr,index+1,hi);
		}
	}
	private static int partition(int[] arr,int lo,int hi){
		int key = arr[lo];
		while(lo<hi){
			while(arr[hi]>=key&&hi>lo){
				hi--;
			}
			arr[lo] = arr[hi];
			while(arr[lo]<=key&&lo<hi){
				lo++;
			}
			arr[hi] = arr[lo];
		}
		arr[hi] = key;
		return hi;
	}

5.归并排序

/**
	 * 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
	 */
	public static void merge(int[] arr){
		merge(arr,0,arr.length-1);
	}
	public static void merge(int[] arr,int left,int right){
		if(left<right){
			//先拆分
			int center = (left+right)/2;
			merge(arr,left,center);
			merge(arr,center+1,right);
			//合并排序
			merging(arr,left,center,right);
		}
	}
	private static void merging(int[] arr, int left, int center, int right) {
		int[] tmpArr = new int[arr.length];
		//右面数组的起始位置
		int midle = center+1;
		int third = left;
		int tmp = left;
		while(left<=center&&midle<=right){
			if(arr[left]<arr[midle]){
				tmpArr[third++] = arr[left++];
			}else{
				tmpArr[third++] = arr[midle++];
			}
		}
		//将剩余部分放入
		while(left<=center){
			tmpArr[third++] = arr[left++];
		}
		while(midle<=right){
			tmpArr[third++] = arr[midle++];
		}
		//将合并排序后的数组复制回原数组
		for(;tmp<=right;tmp++){
			arr[tmp] = tmpArr[tmp];
		}
	}