1.选择排序 2.插入排序 3.希尔排序 4.冒泡排序

需要的方法及实现

private static boolean less(Comparable v, Comparable w) {
   return (v.compareTo(w) < 0);
}

private static void exch(Comparable[] a, int i, int j) {
   Comparable swap = a[i];
   a[i] = a[j];
   a[j] = swap;
} 

• 性能分析：
  一种不稳定的的排序方法，平均时间复杂度为O(n^2)

---

• 选择排序

• 遍历数组，找到最小值，将最小值与数组第一位交换

代码实现：

public class Selection {
	public static void sort(Comparable[] a) {
		int N = a.length;
		for (int i = 0; i < N; i++) {
			int min = i;
			for (int j = i + 1; j < N; j++) {
				if (less(a[j], a[min])) {
					min = j;
				}
			}
			exch(a, i, min);
		}
	}

---

• 插入排序

• 顺序遍历数组，将当前指针指向的元素与其前方每一个元素比较，比自身大就交换，一旦不能交换就停止
  代码实现：

public class Insertion {
	public static void sort(Comparable[] a) {
		int N = a.length;
		for (int i = 0; i < N; i++) {
			for (int j = i; j > 0 && less(a[j], a[j - 1]); j--) {
				exch(a, j, j - 1);
			}
		}
	}

• 性能分析：

1.属于稳定的排序，适合于数据量小，部分数据有序的情况排序。

2.如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需（n-1）次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。插入排序的赋值操作是比较操作的次数加上 (n-1）次。平均来说插入排序算法的时间复杂度为O(n^2）。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择

---

• 希尔排序

• 即特定的的插入排序，被比较元素之间相隔n-1个普通元素，当n=1时与插入排序无异
  代码实现：

public class Shell {
	public static void sort(Comparable[] a) {
		int N = a.length;
		int h = 1;
		while (h < N / 3) {
			h = 3 * h + 1;
		}
		while (h >= 1) {
			for (int i = h; i < N; i++) {
				for (int j = i; j >= h && less(a[j], a[j - h]); j -= h) {
					exch(a, j, j - h);
				}
			}
			h = h / 3;
		}
	}

• 性能分析
  一种不稳定的排序方法。
  时间复杂度分析：最坏时间复杂度依然为O(n2)，一些经过优化的增量序列如Hibbard经过复杂证明可使得最坏时间复杂度为O(n6/5)

---

• 冒泡排序

• 即相邻元素两两比较，每次都可以找到最大的元素放在数组末尾，下一次比较忽略最大元素。
  以下图片来自于此
  代码实现：

public static void bubbleSort(int[] arr){
        public static  void sort(Comparable []a){
        if(a==null||a.length<2){
            return;
        }
            int N = a.length;
            for(int i = 0 ;i<a.length-1;i++) {
                for (int j = 0; j < a.length - i - 1; j++) {
                    if (a[j] > a[j + 1]) {
                        exch(a, j, j+1);
                    }
                }
            }
        }
    }

• 性能分析
  此排序方法是一种稳定的算法，冒泡排序总的平均时间复杂度为：O(n2)