【数据结构和算法】—— 1.选择排序、插入排序

本文链接：https://blog.csdn.net/mqy1023/article/details/74992771

1、O(n^2)排序算法之选择排序**
2、O(n^2)排序算法之插入排序**

一、选择排序

1、实现思路：从最左边下标开始，将该下标的元素和它右边所有元素比较，每一趟遍历找出最小元素的下标，然后将最小下标的元素和该下标元素互换，即每一趟遍历都将最小值放在开始遍历的最左的下标位置
2、int类型数组的选择排序算法

/**
 * 
 * @author eric
 * 从最左边下标开始，将该下标的元素和它右边所有元素比较，每一趟遍历找出最小元素的下标
 * 然后将最小下标的元素和每一趟遍历开始的最左边下标的元素互换，即每一趟遍历都将最小值放在开始遍历的最左的下标位置
 */
public class SelectionSort {

	// 我们的算法类不允许产生任何实例
	private SelectionSort() {
	}

	public static void sort(int[] arr) { // 左边要比较到倒数第二个下标

		int len = arr.length;
		for (int i = 0; i < len - 1; i++) {
			// 寻找[i, n)区间里的最小值的索引
			int minIndex = i;
			for (int j = i + 1; j < len; j++) {
				// 每一趟遍历找出最小元素的下标
				if (arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}
			// 交换开始遍历的最左和最小下标的元素
			if (i != minIndex) {
				swap(arr, i, minIndex);
			}
		}
	}

	/**
	 * 交换两个下标的元素
	 * 
	 * @param arr 要排序的数组
	 * @param i 下标1
	 * @param j 下标2
	 */
	private static void swap(int[] arr, int i, int j) {
		int t = arr[i];
		arr[i] = arr[j];
		arr[j] = t;
	}
}

3、实现了Comparable接口的类，支持泛型排序

1、实现了Comparable接口的类

/**
 * 
 * @author eric
 *
 */
// 实现了Comparable接口的类，支持排序
public class Student implements Comparable<Student> {

	private String name;
	private int score;

	public Student(String name, int score) {
		this.name = name;
		this.score = score;
	}

	// 定义Student的compareTo函数
	// 如果分数相等，则按照名字的字母序排序
	// 如果分数不等，则分数高的靠前
	@Override
	public int compareTo(Student that) {

		if (this.score == that.score)
			return this.name.compareTo(that.name);

		if (this.score < that.score)
			return 1;
		else if (this.score > that.score)
			return -1;
		else // this.score == that.score
			return 0;
	}

	// 定义Student实例的打印输出方式
	@Override
	public String toString() {
		return "Student: " + this.name + " " + Integer.toString(this.score);
	}
}

2、支持泛型排序实现类

public class SelectionSort2 {
	// 我们的算法类不允许产生任何实例
	private SelectionSort2(){}

	/**
	 * 支持泛型比较
	 * @param arr
	 */
	public static <T extends Comparable<T>> void sort(T[] arr){

		int len = arr.length;
		for (int i = 0; i < len - 1; i++) {
			// 寻找[i, n)区间里的最小值的索引
			int minIndex = i;
			for (int j = i + 1; j < len; j++) {
				// 使用compareTo方法比较两个Comparable对象的大小
				if (arr[j].compareTo(arr[minIndex]) < 0) {
					minIndex = j;
				}
			}
			swap(arr, i, minIndex);
		}
	}

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

	public static void main(String[] args) {

		// 测试Integer
		Integer[] a = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		SelectionSort2.sort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]);
			System.out.print(' ');
		}
		System.out.println();

		// 测试Double
		Double[] b = { 4.4, 3.3, 2.2, 1.1 };
		SelectionSort2.sort(b);
		for (int i = 0; i < b.length; i++) {
			System.out.print(b[i]);
			System.out.print(' ');
		}
		System.out.println();

		// 测试String
		String[] c = { "D", "C", "B", "A" };
		SelectionSort2.sort(c);
		for (int i = 0; i < c.length; i++) {
			System.out.print(c[i]);
			System.out.print(' ');
		}
		System.out.println();

		// 测试自定义的类 Student
		Student[] d = new Student[4];
		d[0] = new Student("D", 90);
		d[1] = new Student("C", 100);
		d[2] = new Student("B", 95);
		d[3] = new Student("A", 95);
		SelectionSort2.sort(d);
		for (int i = 0; i < d.length; i++)
			System.out.println(d[i]);
	}
}

二、插入排序

1、普通插入排序实现思路：从右边开始起将相邻元素两两比较后排序。第一趟将最左边两个元素比较排序，右边的大于(或小于)左边的话，两者调换元素位置；第二趟从最左边三个元素右边开始将两两比较排序，… 最后一次是所有元素的相邻元素从右边开始将两两比较排序
```
for (int i = 1; i < len; i++) {
	// 寻找元素arr[i]合适的插入位置
	for( int j = i; j > 0 && arr[j].compareTo(arr[j-1]) < 0 ; j--) {
		swap(arr, j, j-1);
	}  
}
```
改进版插入排序：
- 耗时改进点：每次两两比较后如果有需要都互换位置(耗时：交换每次都需要三次赋值操作，访问数组和访问相应下标的数组数据)，改进后每次将每次都要交换操作变成有必要时一次赋值来节省时间
- 实现思路：因为每一趟遍历排序后(0 —> i-1下标的元素已排好序); 下一趟开始遍历前先复制一份i 下标的元素，然后将i 下标元素和 i - 1 下标元素比较，没互换的需要，此趟直接排序完成(非常省时)；如有需要互换，将 i - 1下标元素放到 i 下标位置，原复制出来的 i 下标元素值再和 i - 2下标元素比较，如有需要互换，将 i - 2 下标元素放到 i - 1 下标位置；没需要互换，将复制出来的 i 下标元素值放在 i - 1 下标位置，此趟排序完成 … 即上一趟排好序的数不断往前推, i 下标元素找到属于自己的位置, 就是每一趟排序完成。
```
   int j;
   for(int i = 1; i < intArray.length; i++){
       int temp = intArray[i];
       j = i;
       while (j > 0 && temp < intArray[j-1]){
           intArray[j] = intArray[j-1];
           j--;
       }
       intArray[j] = temp;
   }
```
时间复杂度：==> 对于几乎有序的数组，插入排序效果非常高，时间复杂度近乎O(n)