AlgorithmStudy1.简单的三种排序方法：冒泡排序，桶排序，快速排序。

1.冒泡排序

时间复杂度：O(n^2)
冒泡排序的基本思想是：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来，每次排序将一个元素归位。

• 代码如下：实现从小到大的排序

package com.timo.sort;

/**
 * @className TestDemo1
 * @description 冒泡排序的实现及测试
 * @author Timo
 *
 */
public class TestDemo1 {
	public static void main(String[] args) {
		int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
		System.out.println("冒泡排序的结果：");
		print(bubbleSort(x));
	}
	/**
	 * 负责数组输出的方法，用加强型for循环
	 * @param array 要输出的数组
	 */
	public static void print(int[] array) {
		for (int i : array) {
			System.out.print(i + ",");
		}
	}
	
	/**
	 * 1.冒泡排序
	 * @param array 要排序的数组
	 * @return array 排序后返回的结果
	 */
	public static int[] bubbleSort(int[] array) {
		// 定义中间变量
		int temp = 0;
		// 控制排序次数
		for (int i = 0; i < array.length; i++) {
			// 控制每次排序的交换次数，数组长度减一保证数组不会出现越界
			for (int j = 0; j < array.length - i - 1; j++) {
				// 相邻的数据进行比较，将大的数据往后移
				if (array[j] > array[j + 1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		return array;
	}
}

2.简单的桶排序

时间复杂度：O(n)
桶排序的基本思想是：首先找到数组中的最大值，然后新建一个数组，这个数组的长度为最大值+1，新建这个数组的下标就是原始数组的数据，那个下标对应的数据出现，对应的下标储存的值加一（从0开始）。0代表这个下标没有对应的数据，下标对应的数据出现几次，对应下标储存的值就几。

• 代码如下：实现从小到大排序

package com.timo.sort;

/**
 * @className TestDemo1
 * @description 桶排序的实现及测试
 * @author Timo
 */
public class TestDemo1 {
	public static void main(String[] args) {
		int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
		int[] bucket = bucketSort(x, maxValue(x));
		System.out.println("桶排序的结果：");
		// 输出排序完的数组
		for (int i = 0; i < bucket.length; i++) {
			for (int j = 0; j < bucket[i]; j++) {
				System.out.print(i + ",");
			}
		}
	}
	
	/**
	 * 2.桶排序的方法
	 * @param array 要进行排序的数组
	 * @param maxNum 待排序数组的最大值
	 * @return bucket 记录每个数据出现次数的数组
	 */
	public static int[] bucketSort(int[] array, int maxNum) {
		// 创建桶数组
		int[] bucket = new int[maxNum + 1];
		for (int i = 0; i < bucket.length; i++) {
			for (int j = 0; j < array.length; j++) {
				// 记录每个值出出现的次数，保存在桶数组中
				if (i == array[j]) {
					bucket[i]++;
				}
			}
		}
		return bucket;
	}
	
	/**
	 * 求数组的最大值
	 * @param array 要求最大值的数组
	 * @return temp 最大值
	 */
	public static int maxValue(int[] array) {
		// 定义保存最大值的变量，并赋值
		int maxNum = array[0];
		for (int i = 1; i < array.length; i++) {
			// 进行数据比较，将大的值赋给maxNum
			if (maxNum < array[i]) {
				maxNum = array[i];
			}
		}
		return maxNum;
	}
}

3.快速排序

时间复杂度：O(NlogN)
快速排序的基本思想：每次排序的时候设置一个基准值，将小于基准值的数全部放到基准值的左边，将大于基准值的数全部放到基准值的右边，每次将基准值归位。然后以基准值为中心分而制之，进行递归。即每一轮处理其实就是将这一轮的基准值归位。

• 方法一：快速排序的代码实现

package com.timo.sort;

/**
 * @className TestDemo1
 * @description 快速排序的测试及实现1
 * @author Timo
 */
public class TestDemo1 {
	public static void main(String[] args) {
		int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
		quickSort(x, 0, x.length - 1);
		System.out.println("快速排序的结果：");
		print(x);
	}
	
	/**
	 * 负责数组输出的方法，用加强型for循环
	 * @param array 要输出的数组
	 */
	public static void print(int[] array) {
		for (int i : array) {
			System.out.print(i + ",");
		}
	}
	
	/**
	 * 3.快速排序
	 * @param array 要进行排序的数组
	 * @param left left = 0;
	 * @param right right = array.length - 1;
	 */
	public static void quickSort(int array[], int left, int right) {
		// 排序的出口
		if (left > right || array.length <= 0) {
			return;
		}
		// 定义i，j，和基准值key
		int i = left;
		int j = right;
		int key = array[left];
		while (i != j) {
			// j向前走，找到第一个碰到的小于基准值的数
			while (array[j] >= key && i < j) {
				j--;
			}
			// i向后走，找到第一个碰到的大于基准值的数
			while (array[i] <= key && i < j) {
				i++;
			}
			// 将找到的两个数交换位置
			if (i < j) {
				int temp = array[i];
				array[i] = array[j];
				array[j] = temp;
			}
		}
		// 将基准值归位
		array[left] = array[i];
		array[i] = key;
		// 继续排序基准值左边的元素
		quickSort(array, left, i - 1);
		// 继续排序基准值右边的元素
		quickSort(array, i + 1, right);
	}
}

• 方法二：快速排序的代码实现

package com.timo.sort;

/**
 * @className TestDemo1
 * @description 快速排序的测试及实现2
 * @author Timo
 */
public class TestDemo1 {
	public static void main(String[] args) {
		int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
		quickSort(x, 0, x.length - 1);
		System.out.println("快速排序的结果：");
		print(x);
	}
	
	/**
	 * 负责数组输出的方法，用加强型for循环
	 * @param array 要输出的数组
	 */
	public static void print(int[] array) {
		for (int i : array) {
			System.out.print(i + ",");
		}
	}
	
	/**
	 * 3.快速排序
	 * @param array 要进行排序的数组
	 * @param left left = 0;
	 * @param right right = array.length - 1;
	 */
	public static void quickSort(int array[], int left, int right) {
		if (left > right || array.length<=0) { // i大于或等于j，直接返回
			return;
		}
		int i = left; 	// i，左下标
		int j = right; 	// j，右下标
		int key = array[left]; // 基准元素，默认取数组的第一个元素
		// 让数组中的全部元素都比较，每次轮将基准值归位
		while (true) {
			// j往前走
			while (j > i) {
				if (array[j] < key) { // 找到第一个小于key的值A[j]，A[i]与A[j]交换
					int temp = array[j];
					array[j] = array[i];
					array[i] = temp;
					break;
				} else {
					j--;
				}
			}
			// i往后走
			while (j > i) {
				if (array[i] > key) { // 找到第一个大于key的A[i]，A[i]与A[j]交换
					int temp = array[j];
					array[j] = array[i];
					array[i] = temp;
					break;
				} else {
					i++;
				}
			}
			// 终结最外层while循环，表示一趟排序结束（全部元素都进行了比较）
			if (i == j) {
				break;
			}
		}
		// 继续排序基准元素的左边元素
		quickSort(array, left, i - 1);
		// 继续排序基准元素的右边元素
		quickSort(array, i + 1, right);
	}
}