排序算法（一）

1、冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的元素。

3. 针对所有的元素重复以上步骤，除了最后一个。

4. 重复1~3的步骤直到排序完成。

5. 然后对余下的数进行第二趟比较，如果有n个数，则要进行n-1趟比较。在第一趟比较要进行n-1次两两比较，在第j趟比较要进行n-j次两两比较。

public class BubbleSort {
    	public static void bubbleSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			// i=1, j=4
			// i=2, j=3
			// i=3, j=2
			// j=arr.length-1-i
			for (int j = 0; j <= arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

	public static void main(String[] args) {
		int[] arr = { 9, 8, 5, 4, 2, 0 };
		bubbleSort(arr);
		System.out.println(Arrays.toString(arr));
	}
}

2、快速排序

1. 先从数列中取出一个 数作为基准数。

2. 分区过程，将比这个数大的数全放到他的右边，小于或则等于他的数全放到他的左边。

3. 在对左右区间重复第二步，直到各区间只有一个数。

public class QuickSort {
	public static void quickSort(int[] arr, int low, int high) {
		if (low < high) {
			// 1. 定义基准pivot,
			int pivot = arr[low];
			// ...... pivot移动到中间，左边都比pivot小，后边都比pivot大, index
			int i = low;
			int j = high;

			while (i < j) {
				while (i < j && arr[j] >= pivot) {
					j--;
				}
				// 交换
				swap(arr, i, j);
				while (i < j && arr[i] <= pivot) {
					i++;
				}
				// 交换
				swap(arr, i, j);
			}
			// 2. 递归对左右2部分快排
			quickSort(arr, low, j - 1);//j-1不可以写成j--，在编译时没有结果
			quickSort(arr, j + 1, high);
		}
	}
	
	public static void swap(int arr[], int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public static void main(String[] args) {
		int[] arr = { 5, 3, 7, 6, 4, 1, 0, 2, 9, 10, 8 };
		quickSort(arr, 0, arr.length - 1);
		System.out.println(Arrays.toString(arr));
	}
}