排序算法_选择排序

之前我们讨论过冒泡排序，这次我们来接触一下选择排序。

选择排序就是要（假如我们是升序排序）每次选择出剩下序列中最小的元素放到当前序列的首位置。前面我们学的冒泡排序，那个是两个邻居元素相互比较，把最大的元素依次‘推’到序列的末端；而选择排序就是通过“打擂”的思想找出最小或最大的元素后，将其与序列首部或尾部交换来达成排序的目的的。

wikipeda上的动态图：

假如我们要排序的序列为：

我们要从当前序列中找到最小的元素放到0号位置，也就是和元素56交互位置。如果我们把0号位置后的每一个位置都与0号位置元素进行比较大小，只要比当前0号位置的数小就与0号位置交互元素。那么第一轮将发生如下交换：

设括号里面为元素交换后的位置，右边为上一刻处在0号位置的元素：

25与56交换，25(0), 56(1)

19与25交换，19(0), 25(5)

一轮下来结果为：

下一轮从1号位置开始，循环这个过程。共有N-1(本例中N=8)轮排序，最后一个位置在前N-1轮排序后为序列中值最大的元素。

Java选择排序示例代码如下：

public class MySelection {
	public static void sort(int[] array) {
		for (int i = 0; i < array.length - 1; i++) {
			for (int j = i + 1; j < array.length; j++) {
				if (array[i] > array[j]) {
					int tmp = array[i];
					array[i] = array[j];
					array[j] = tmp;
				}       
			}
		}
	}
	
	public static void main(String[] args) {
		int[] array = new int[]{56, 25, 37, 58, 95, 19, 73, 30};
		sort(array);
		for (int a : array)
			System.out.printf("%-5d", a);
		 System.out.println();
	}
}

稍微改进的代码，每次只记录最小元素的索引，每次只交换一次:

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

再次改进后的选择排序，每轮只交换一次，记录位置信息后在每一轮结束时交互：

public class SelectionSort {
	
	public void sort(int[] array) {
		for (int lh = 0; lh < array.length - 1; lh++) {
			int rh = findSmallest(array, lh);
			swapArrayElements(array, lh, rh);
		}
	}
	
	private int findSmallest(int[] array, int start) {
		int rh = start;
		for (int i = start + 1; i < array.length; i++) {
			if (array[i] < array[rh]) {
				rh = i;
			}
		}
		return rh;
	}
	
	private void swapArrayElements(int[] array, int p1, int p2) {
		int tmp = array[p1];
		array[p1] = array[p2];
		array[p2] = tmp;
	}
	
	public static void main(String[] args) {
		int[] array = new int[]{1, 5, 4, 2, 3};
		new SelectionSort().sort(array);
		for (int i = 0; i < array.length; i++)
			System.out.printf("%-5d", array[i]);
		System.out.println();
	}
}

还有递归形式：

	public static void recursiveSelection(int[] arr, int low, int high) {
		if (low < high) {
			int indexOfMin = low;
			for (int i = low + 1; i < high; i++) {
				if (arr[indexOfMin] > arr[i]) 
					indexOfMin = i;
			}
			
			int temp = arr[low];
			arr[low] = arr[indexOfMin];
			arr[indexOfMin] = temp;
			recursiveSelection(arr, low + 1, high);
		}
	}

和冒泡排序的复杂度一样，选择排序的复杂度也是O(N^2)