排序算法：冒泡排序，选择排序，插入排序

冒泡排序，选择排序，插入排序都是n平方的时间复杂度

下面使用Java代码实现这三种排序

1、冒泡排序

思路：嵌套循环，每次查看相邻的元素如果逆序，则交换

public class BubbleSort {

	@Test
	public void test() {
		int[] nums = {2,1,5,3,4};
		sort(nums);
		System.out.println(Arrays.toString(nums));
	}
	
	/**
	 * 冒泡排序，升序
	 * 嵌套循环，每次查看相邻的元素如果逆序，则交换
	 * @param nums
	 */
	public void sort(int[] nums) {
		for(int i=0; i<nums.length-1; i++) {
			for(int j=0; j<nums.length-i-1; j++) {
				if(nums[j]>nums[j+1]) {
//					int tmp = nums[j];
//					nums[j] = nums[j+1];
//					nums[j+1] = tmp;
					
					nums[j] = nums[j] ^ nums[j+1];
					nums[j+1] = nums[j] ^ nums[j+1];
					nums[j] = nums[j] ^ nums[j+1];
				}
			}
		}
	}
}

2、选择排序

思路：每次从未排序中找最小值，放在待排序数组的起始位置

public class SelectionSort {

	@Test
	public void test() {
		int[] nums = {2,1,5,3,4};
		sort(nums);
		System.out.println(Arrays.toString(nums));
	}
	
	/**
	 * 选择排序，升序
	 * 左边已排序，右边未排序
	 * 每次从未排序中找最小值，放在待排序数组的起始位置
	 * @param nums
	 */
	public void sort(int[] nums) {
		for(int i=0; i<nums.length-1; i++) {
			for(int j=i+1; j<nums.length; j++) {
				if(nums[i]>nums[j]) {
					int tmp = nums[i];
					nums[i] = nums[j];
					nums[j] = tmp;
				}
			}
		}
	}
}

3、插入排序

思路：从前到后逐步构建有序序列；左边是已排序序列，右边是未排序序列；从未排序序列中选择一个元素，在已排序序列中从后向前扫描，找到相应位置插入

public class InsertionSort {

	@Test
	public void test() {
		int[] nums = {2,1,5,3,4};
		sort(nums);
		System.out.println(Arrays.toString(nums));
	}
	
	/**
	 * 插入排序，升序
	 * 从前到后逐步构建有序序列
	 * 左边是已排序序列，右边是未排序序列
	 * 从未排序序列中选择一个元素，在已排序序列中从后向前扫描，找到相应位置插入
	 * @param nums
	 */
	public void sort(int[] nums) {
		//i位置是待排序的数组元素，(0,i-1]是已经排好序的
		for(int i=1; i<nums.length; i++) {
			int value = nums[i];
			int j = i-1;
			for(; j>=0; j--) {
				//已排序的最后一个元素开始，只要比待排序的这个元素大，就往后移一个位置
				if(nums[j]>value) {
					nums[j+1] = nums[j];
				} else {
					break;
				}
			}
			nums[j+1] = value;
		}
	}
}