内功修炼之O(n²)的排序算法（一）

*本文参考程序员内功修炼课程，所有实现代码均能在github上找到。

一、选择排序(Selection Sort)

    1） 基本思想：给定数组int[] arr={里面n个数据}；第1趟排序，在待排序数据arr[1]~arr[n]中选出最小的数据，将它与arr[1]交换；第2趟，在待排序数据arr[2]~arr[n]中选出最小的数据，将它与arr[2]交换；以此类推，第i趟在待排序数据arr[i]~arr[n]中选出最小的数据，将它与r[i]交换，直到全部排序完成。

    2 )  代码实现：

public class SelectionSort {
	private SelectionSort() {
	}

	public static void selectionSort(int[] array) {
		for (int i = 0; i < array.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < array.length; j++) {
				if (array[j] < array[minIndex]) {
					minIndex = j;
				}
			}
			if (minIndex != i) {
				swap(array, i, minIndex);
			}
		}
	}

	private static void swap(int[] array, int i, int minIndex) {
		int temp = array[i];
		array[i] = array[minIndex];
		array[minIndex] = temp;
	}
}

    3） 算法分析：算法核心在于找到带排序元素中的最小值。

                1. 我们记录待排序元素中最小值的索引，开始假定待排序的元素中第一个元素是最小值，继续往后遍历；

                2. 如果有元素小于索引处的值，则将索引修改为该元素索引；

二、 插入排序（Insertion Sort）

      1） 基本思想：  给定数组int[] arr={里面n个数据}；第1趟排序，将arr[1]和arr[0]比较，将最小值排在前；第2趟，将arr[2]插入已排好序的arr[0]~arr[1]中合适的位置；以此类推，第i趟将arr[i]插入已排好序的arr[0]~arr[i-1]中合适的位置，直到全部排序完成。

       2） 代码实现：

public class InsertionSort {

	private InsertionSort() {
	}

	public static void insertionSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			int j;
			int current = arr[i];
			for (j = i; j > 0 && arr[j - 1] > current; j--) {
				arr[j] = arr[j - 1];
			}
			arr[j] = current;
		}
	}
}

        3） 算法分析：算法核心在于将待排序元素插入已排序元素中合适的位置。

1. 记录待排序元素值，将记录元素前一位已排好序的元素与记录元素进行比较：如果大于记录值，则将前一位元素后移，索引前移；如果小于记录值， 将当前索引处的值置为记录值。

三、冒泡排序（Bubble Sort）

        1） 基本思想：给定数组int[] arr={里面n个数据}；第1趟排序，将arr[0]和arr[1]比较，如果arr[0]>arr[1],交换两者位置；第2趟，将arr[1]和arr[2]比较，如果arr[1]>arr[2]，交换两者位置；第i趟，将arr[i-1]和arr[i]比较，如果arr[i-1]>arr[i]，交换两者位置；以此类推，直到全部排序完成。

        2） 代码实现：

public class BubbleSort {
	private BubbleSort() {
	}

	public static void sort(int[] arr) {
		int length = arr.length;
		boolean swapped = true;
		for (int i = 0; swapped; i++) {
			swapped = false;
			for (int j = 0; j < length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(arr, j, j + 1);
					swapped = true;
				}
			}
		}
	}

	private static void swap(int[] arr, int j, int i) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

        3） 算法分析：此处对于原本的冒泡算法做了优化：如果没有再进行位置交换说明数组已经有序，此时终止排序。这样对于完全有序的数组排序效率提升巨大；对于基本有序数组，效率略有提升。