八大排序

冒泡排序：

语言描述：依次比较相邻的两个数字进行比较，每比较一轮确定一个位置，比较n-1轮即可，时间复杂度为o(n2)

public static void Sort(int[] array) {
		for(int i = 0;i < array.length - 1; i++) {
			for(int j = 0;j < array.length - i - 1; j++) {
				if(array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

选择排序：

语言描述：每次选择剩余数字中最小（大）的数字，进行交换，每次确定一个位置，时间复杂度o(n2),是冒泡排序的改进版

public static void Sort(int[] array) {
		for(int i = 0;i < array.length - 1; i++) {
			int selected = i;
			for(int j = i + 1;j < array.length; j++) {
				if(array[j] < array[selected]) {
					selected = j;
				}
			}
			int temp = array[i];
			array[i] = array[selected];
			array[selected] = temp;
		}
	}

插入排序

语言描述：将还未排序的数字插入到已经排序的数组中，插入n-1次，时间复杂度o(n2)

public static void Sort(int[] array) {
		for(int i = 1; i < array.length; i++) {
			int toinsert = array[i];
			int j;
			for(j = i - 1;j >= 0; j--) {
				if(toinsert > array[j]) {
					break;
				}
				array[j + 1] = array[j];
			}
			array[j + 1] = toinsert;
		}
	}

快速排序

语言描述：选取数列中某个数，例如第一个数nums[0]，将比nums[0]大的数放在它的右边，将nums[0]小的数放在它的左边，此时nums[0]的位置确定，再对nums[0]左侧的数字和右侧的数字进行相同的操作。

private static void sort(int[] nums,int left,int right) {
		if(left >= right) {
			return;
		}
		int low = left; 
		int high = right;
		int target = nums[left];
		while(low < high) {
			while(low < high && nums[high] >= target) {
				high--;
			}
			if(low < high) {
				nums[low] = nums[high];
				low++;
			}
			while(low < high && nums[low] < target) {
				low++;
			}
			if(low < high) {
				nums[high] = nums[low];
				high--;
			}
		}
		nums[low] = target;
		sort(nums,left,low - 1);
		sort(nums,low + 1,right);
	}

基数排序

语言描述：
该方法只适用于整数之间的排序。首先按个位排序，再按十位排序，以此类推，直到最大值的最高位被排序。

private static void sort(int[] nums) {
		int max_num = Integer.MIN_VALUE;
		int len = nums.length;
		//找到最大值
		for(int i = 0; i < len; i++) {
			max_num = Math.max(max_num, nums[i]);
		}
		System.out.println(max_num);
		int digit_num = 0;
		//找到最大值的位数，即循环的次数
		while(max_num > 0) {
			max_num /= 10;
			digit_num++;
		}
		System.out.println(digit_num);
		int beishu = 1;
		//按个位，十位，百位...进行排序
		for(;digit_num > 0; digit_num--) {
			//记录每个位的个数
			int[] counts = new int[10];
			//记录每个位的数值
			int[][] temp_nums = new int[10][len];
			for(int i = 0; i < len; i++) {
				int last_digit = nums[i] / beishu % 10;
				temp_nums[last_digit][counts[last_digit]++] = nums[i];
			}
			int index = 0;
			//对nums数组重新排序
			for(int i = 0; i < 10; i++) {
				for(int j = 0; j < counts[i]; j++) {
					nums[index++] = temp_nums[i][j];
				}
			}
			beishu *= 10;
		}
	}

归并排序

语言描述：首先将数组分为左右两部分，两部分数组分别有序，那么数组怎么有序呢，使用递归，将左部分同样分为两部分，右部分也同样分为两部分，一步步往下，最后得到有序的两部分，再将两个有序数组进行合并

private static int[] sort(int[] nums,int left,int right) {
		//终止条件，是数组中只有一个数
		if(right == left) {
			return new int[] {nums[left]};
		}
		int middle = left + (right - left) / 2;
		//对数组左侧进行递归
		int[] arr_left = sort(nums, left, middle);
		//对数组右侧进行递归
		int[] arr_right = sort(nums, middle + 1, right);
		int len_left = arr_left.length;
		int len_right = arr_right.length;
		int[] new_arr = new int[len_left + len_right];
		int index = 0;
		int index_left = 0;
		int index_right = 0;
		//将2个有序数组进行合并
		while(index_left < len_left && index_right < len_right) {
			new_arr[index++] = arr_left[index_left] < arr_right[index_right]? arr_left[index_left++] : arr_right[index_right++];
		}
		while(index_right < len_right) {
			new_arr[index++] = arr_right[index_right++];
		}
		while(index_left < len_left) {
			new_arr[index++] = arr_left[index_left++];
		}
		return new_arr;
	}