数据结构与算法day17-选择排序算法

基本介绍：
	选择排序也属于内部排序法，是从要排序的数据中，按指定的规则选出
	某一元素，再依规定交换位置后达到排序的目的

选择排序思想：
	选择排序(Select Sorting)也是一种简单的排序方法，它的基本思想是：第一次
	从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]~arr[n-1]
	中选取最小值，与arr[1]交换，第三次从arr[2]~arr[n-1]中选取最小值，
	与arr[2交换],以此类推。
	即第i次从ar[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，...第n-1次
	从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次
	得到一个排序码从小到大排序的有序序列。

选择排序图解如下：

说明：
1.选择排序一共有arr.size-1轮排序
2.每一轮排序又是一个循环，循环规则：
	1.先假定当前这个数是最小值
	2.然后和后面的每一个数进行比较如果发现有比当前数更小的数，
		就重新确定最小数，并得到下标
	3.当遍历到数组的最后时，就得到本轮最小数和下标
	4.交换
	
选择排序应用实例：
	有一群牛，颜值分别是 101, 34, 119,1请使用
	选择排序从低到高进行排序[101, 34, 119,1]

笨代码如下：推导代码

package day07;

import java.util.Arrays;

public class SelectSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = {101, 34, 119, 1};
		selectSort(array);
	}
	
	// 选择排序
	public static void selectSort(int[] array) {
		// 使用逐步推导的方式，讲解选择排序
		// 第一轮
		// 原始的数组：101, 34, 119, 1
		// 第一轮排序：1. 34, 119, 101
		// 算法先简单--> 再复杂
		// 		可以把一个复杂的算法，拆成简单问题，逐步解决
		
		// 第1轮
		int minIndex = 0;
		int min = array[0];
		for (int j = 0+1; j < array.length; j++) {
			if (min > array[j]) {// 说明假定的最小值，是暂时的最小
				min = array[j]; // 重置min
				minIndex = j; // 重置minIndex
			}
		}
		
		// 将最小值，放在array[0]，即交换
		if (minIndex != 0) {
			array[minIndex] = array[0];
			array[0] = min;
		}
		
		System.out.println("第一轮后~");
		System.out.println(Arrays.toString(array));
		
		
		// 第2轮
		minIndex = 1;
		min = array[1];
		for (int j = 1+1; j < array.length; j++) {
			if (min > array[j]) {// 说明假定的最小值，是暂时的最小
				min = array[j]; // 重置min
				minIndex = j; // 重置minIndex
			}
		}
		
		// 将最小值，放在array[0]，即交换
		if (minIndex != 1) {
			array[minIndex] = array[1];
			array[1] = min;
		}
		
		System.out.println("第2轮后~");
		System.out.println(Arrays.toString(array));
		
		
		// 第3轮
		minIndex = 2;
		min = array[2];
		for (int j = 2+1; j < array.length; j++) {
			if (min > array[j]) {// 说明假定的最小值，是暂时的最小
				min = array[j]; // 重置min
				minIndex = j; // 重置minIndex
			}
		}
		
		// 将最小值，放在array[0]，即交换
		if (minIndex != 2) {
			array[minIndex] = array[2];
			array[2] = min;
		}
		
		System.out.println("第3轮后~");
		System.out.println(Arrays.toString(array));
	}

}

通用代码如下：

package day07;

import java.util.Arrays;

public class SelectSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = {101, 34, 119, 1};
		selectSort(array);
		
		System.out.println("排序后~");
		System.out.println(Arrays.toString(array));
	}
	
	// 选择排序
	public static void selectSort(int[] array) {
		// 使用逐步推导的方式，讲解选择排序
		// 第一轮
		// 原始的数组：101, 34, 119, 1
		// 第一轮排序：1. 34, 119, 101
		// 算法先简单--> 再复杂
		// 		可以把一个复杂的算法，拆成简单问题，逐步解决
		
		// 时间复杂度是O(n^2)
		for (int i = 0; i < array.length-1; i++) {
			int minIndex = i;
			int min = array[i];
			for (int j = i+1; j < array.length; j++) {
				// 若改成逆序排序，只需要修改成<
				if (min > array[j]) {// 说明假定的最小值，是暂时的最小
					min = array[j]; // 重置min
					minIndex = j; // 重置minIndex
				}
			}
			
			// 将最小值，放在array[0]，即交换
			if (minIndex != i) {
				array[minIndex] = array[i];
				array[i] = min;
			}
			
		}
		
	}
}

测试选择排序代码运行事件：运用接口动态代理

package day07;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class SelectSort implements MySort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SelectSort ss = new SelectSort();
		int[] array = new int[80000];
		
		for (int i = 0; i < 80000; i++) {
			array[i] = (int) (Math.random() * 80000);
		}
		
		MySort proxyS =  (MySort) Proxy.newProxyInstance(ss.getClass().getClassLoader(),
			ss.getClass().getInterfaces(), new InvocationHandler() {

				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					// TODO Auto-generated method stub
					if ("selectSort".equals(method.getName())) {
						long start = System.currentTimeMillis();
						
						method.invoke(ss, args);
						
						long end = System.currentTimeMillis();
						
						System.out.println("消耗时间：" + (end-start) + "ms");
					}
					return null;
				}
			
		});
		
		proxyS.selectSort(array);
	}
	
	// 选择排序
	public void selectSort(int[] array) {
		// 使用逐步推导的方式，讲解选择排序
		// 第一轮
		// 原始的数组：101, 34, 119, 1
		// 第一轮排序：1. 34, 119, 101
		// 算法先简单--> 再复杂
		// 		可以把一个复杂的算法，拆成简单问题，逐步解决
		
		// 时间复杂度是O(n^2)
		for (int i = 0; i < array.length-1; i++) {
			int minIndex = i;
			int min = array[i];
			for (int j = i+1; j < array.length; j++) {
				// 若改成逆序排序，只需要修改成<
				if (min > array[j]) {// 说明假定的最小值，是暂时的最小
					min = array[j]; // 重置min
					minIndex = j; // 重置minIndex
				}
			}
			
			// 将最小值，放在array[0]，即交换
			if (minIndex != i) {
				array[minIndex] = array[i];
				array[i] = min;
			}
			
		}
		
	}

}