java中排序算法集

java排序算法包括了很多种，包括了插入排序、选择排序、快速排序、归并排序、桶排序、堆排序等等一系列的。

一、选择排序的递归与非递归实现

首先是非递归实现，代码如下。

	/**
	 * TODO:非递归选择排序算法(每次找出列表中最小元素或者最大元素放到当前列表的开始位置)
	 * @param noSortList 带排序的列表
	 * @return Integer[] 排好序的列表
	 * @author 邪恶小先生
	 * @time 2017年11月5日
	 */
	public static Integer [] selectionSort(Integer [] noSortList){
		for(int i = 0; i < noSortList.length - 1; i ++){
			//初始化最开始为最小
			int minElementIndex = i;
			for(int j = i + 1; j < noSortList.length; j ++){
				if(noSortList[j] < noSortList[minElementIndex]){
					minElementIndex = j;
				}
			}
			//交换元素
			if(!(minElementIndex == i)){
				int temp = noSortList[i];
				noSortList[i] = noSortList[minElementIndex];
				noSortList[minElementIndex] = temp;
			}
		}
		return noSortList;
	}

选择排序递归实现，代码如下。

	/**
	 * TODO:递归实现选择选择排序算法，每一次递归都将最小的移动到当前队列第一个元素的位置
	 * @return Integer[]
	 * @author 邪恶小先生
	 * @time 2017年11月9日
	 */
	public static Integer [] selectionSortWithRecursion(int nowStartIndex,Integer [] noSortList){
		if(nowStartIndex >= noSortList.length){
			return noSortList;
		}
		//初始化最小元素为nowStartIndex的地方的元素
		int minElementIndex = nowStartIndex;
		int i;
		//寻找最小元素下标
		for(i = nowStartIndex; i < noSortList.length; i ++){
			if(noSortList[i] < noSortList[minElementIndex]){
				minElementIndex = i;
			}
		}
		//如果下标有变动就执行交换代码块
		if(minElementIndex!=nowStartIndex){
			int temp = noSortList[nowStartIndex];
			noSortList[nowStartIndex] = noSortList[minElementIndex];
			noSortList[minElementIndex] = temp;
		}
		//递归进行
		return selectionSortWithRecursion(nowStartIndex+1,noSortList);
	}

二、插入排序

插入排序非递归实现，代码如下。

	/**
	 * 
	 * TODO:非递归插入排序算法
	 * @return Integer[]
	 * @author 邪恶小先生
	 * @time 2017年11月9日
	 */
	public  static Integer [] insertSort(Integer [] noSortedList){
		for(int i = 1; i < noSortedList.length; i ++){
			int j = 0;
			//找插入的位置
			while(j < i){
				if(noSortedList[i] > noSortedList[j]){
					j++;
				}
				else{
					break;
				}
			}
			//当前被插入的元素所在的位置就正好是要插入，不需要变动
			if(!(j == i)){
				//将当前被插入的元素记录下来
				int temp = noSortedList[i];
				//移动后面元素的位置
				for(int m = i; m > j; m -- ){
					noSortedList[m] = noSortedList[m-1];
				}
				//进行插入
				noSortedList[j] = temp;
			}
		}
		return noSortedList;
	}

三、冒泡排序

	/**
	 * TODO:非递归方式的冒泡排序
	 * @param noSortList 带排序的列表
	 * @return Integer[] 排好序的列表
	 * @author 邪恶小先生
	 * @time 2017年11月5日
	 */
	public static Integer [] bubbleSort(Integer [] noSortList){
		//蛮力，just do it
		//外层循环用于控制已经排好序的元素不在进行排序
		for(int i = 0; i < noSortList.length; i ++){
			//标识当前列表是否已经有序，如果已经有序，就不用在进行排序
			boolean isInOrder = true;
			//后面排好序的就不用排序了，所以是noSortList.length - i
			for(int j = 1; j < noSortList.length - i - 1; j ++){
				if(noSortList[j] > noSortList[j+1]){
					//表明列表是无序的
					isInOrder = false;
					//swap两个元素
					int temp = noSortList[j];
					noSortList[j] = noSortList[j + 1];
					noSortList[j + 1] = temp;
				}
			}
			//表明列表是有序的，直接退出循环，避免下一次排序
			if(isInOrder){
				break;
			}
		}
		return noSortList;
	}

四、快速排序算法

package q.experience.exp2;

/**
 * @author 邪恶小先生
 */
public class QuickSort {
	/**
	 * TODO:主调算法
	 * @return void
	 * @author 邪恶小先生
	 * @time 2017年11月21日
	 */
	public static void quickSort(Integer [] noSortedList){
		quickSort(noSortedList,0,noSortedList.length - 1);
	}
	
	/**
	 * TODO:重载的方法
	 * @return void
	 * @author 邪恶小先生
	 * @time 2017年11月21日
	 */
	private static void quickSort(Integer [] partList,int first,int last){
		if(last > first){
			int pivotIndex = partition(partList, first, last);
			//分别对前后部分进行快速排序
			quickSort(partList,first,pivotIndex - 1);
			quickSort(partList,pivotIndex + 1, last);
		}
	}
	
	/**
	 * 
	 * TODO:主要的操作函数，进行元素的移动，将比主元小的元素往左边移动，比主元大的元素向右移动，返回主元正确的下标
	 * @return void
	 * @author 邪恶小先生
	 * @time 2017年11月21日
	 */
	public static int partition(Integer [] partList,int first, int last){
		//列表第一个元素作主元
		int pivot = partList[first];
		//从左向右扫描的下标开始处
		int low = first + 1;
		//从右向左扫描的下标开始处
		int high = last;
		
		//前后扫描整个列表，将比主元大的和小的分别隔开到两端
		while(high > low){
			//从左向右扫描第一个大于主元的元素，退出循环的时候要么是越过了界限，要么就是找到了第一个比主元大的元素
			while(low<=high && partList[low] <= pivot){
				//向右移动
				low ++;
			}
			
			//从右向左扫描第一个小于主元的元素，退出循环的时候要么是越过了界限，要么就是找到了第一个比主元大的元素
			while(low <= high && partList[high] > pivot){
				//向左移动
				high --;
			}
			
			//经过上面两个步骤，便找到了第一个比主元大的，和第一个比主元小的元素下标，或者越界
			//如果没有发生越界，交换两个元素
			if(high > low){
				int temp = partList[high];
				partList[high] = partList[low];
				partList[low] = temp;
			}
		}
		
		//现在确定主元pivot的位置
		while(high > first && partList[high] >= pivot){
			high --;
		}
		
		//插入主元，返回主元所在的位置
		if(pivot > partList[high]){
			partList[first] = partList[high];
			partList[high] = pivot;
			return high;
		}else{
			return first;
		}
	}
	
	public static void main(String [] args){
		Integer [] list = {2,3,2,5,6,1,-2,3,14,12};
		quickSort(list);
		System.out.println("排序完成");
		for(int i = 0; i < list.length; i ++){
			System.out.println(list[i]);
		}
	}
}