算法之插入排序学习

该文是对插入排序算法的一些总结和学习，具体代码和注释如下：

Insertion.java
/*插入排序特点：
运行时间和输入无关，数据移动是最少的（交换次数和数组大小是线性关系）。
*/
Below is the syntax highlighted version of Insertion.java from §2.1 Elementary Sorts.
/*
*简单来说就是挨个把数组内容拿出来然后再以排序的数组中再次遍历其应有位置并插入
*/

 

import java.util.Comparator;

 

//方法本体
public class Insertion {

// This class should not be instantiated.//该方法不能被实例化
private Insertion() { }

/**
* Rearranges the array in ascending order, using the natural order.
* @param a the array to be sorted
*/

//升序，仅给出a[]的情况

public static void sort(Comparable[] a) {
int n = a.length;
for (int i = 1; i < n; i++) {
for (int j = i; j > 0 && less(a[j], a[j-1]); j--) {//比较j和j-1位大小并交换
exch(a, j, j-1);//j，j-1换位
}
assert isSorted(a, 0, i);//断言其排序成功
}
assert isSorted(a);//断言a为排序后的结果
}

//升序，采用左右上下界
public static void sort(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i < hi; i++) {
for (int j = i; j > lo && less(a[j], a[j-1]); j--) {
exch(a, j, j-1);
}
}
assert isSorted(a, lo, hi);
}

//方向问题
public static void sort(Object[] a, Comparator comparator) {
int n = a.length;
for (int i = 1; i < n; i++) {
for (int j = i; j > 0 && less(a[j], a[j-1], comparator); j--) {
exch(a, j, j-1);
}
assert isSorted(a, 0, i, comparator);
}
assert isSorted(a, comparator);
}

//上下界加升降序
public static void sort(Object[] a, int lo, int hi, Comparator comparator) {
for (int i = lo + 1; i < hi; i++) {
for (int j = i; j > lo && less(a[j], a[j-1], comparator); j--) {
exch(a, j, j-1);
}
}
assert isSorted(a, lo, hi, comparator);
}

// return a permutation that gives the elements in a[] in ascending order
// do not change the original array a[]

//用数组表示数
public static int[] indexSort(Comparable[] a) {
int n = a.length;
int[] index = new int[n];
for (int i = 0; i < n; i++)
index[i] = i;

for (int i = 1; i < n; i++)
for (int j = i; j > 0 && less(a[index[j]], a[index[j-1]]); j--)
exch(index, j, j-1);

return index;
}

/***************************************************************************
* Helper sorting functions.
***************************************************************************/
//less方法，返回是否前比后小
// is v < w ?
private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
//带方向的比较
// is v < w ?
private static boolean less(Object v, Object w, Comparator comparator) {
return comparator.compare(v, w) < 0;
}
//改变两者位置
// exchange a[i] and a[j]
private static void exch(Object[] a, int i, int j) {
Object swap = a[i];
a[i] = a[j];
a[j] = swap;
}
//int型
// exchange a[i] and a[j] (for indirect sort)
private static void exch(int[] a, int i, int j) {
int swap = a[i];
a[i] = a[j];
a[j] = swap;
}

/***************************************************************************
* Check if array is sorted - useful for debugging.
***************************************************************************/
//返回数组
private static boolean isSorted(Comparable[] a) {
return isSorted(a, 0, a.length);
}

// is the array a[lo..hi) sorted
//返回带范围区间的数组
private static boolean isSorted(Comparable[] a, int lo, int hi) {
for (int i = lo + 1; i < hi; i++)
if (less(a[i], a[i-1])) return false;
return true;
}
//返回带排序方式的数组
private static boolean isSorted(Object[] a, Comparator comparator) {
return isSorted(a, 0, a.length, comparator);
}

// is the array a[lo..hi) sorted
private static boolean isSorted(Object[] a, int lo, int hi, Comparator comparator) {
for (int i = lo + 1; i < hi; i++)
if (less(a[i], a[i-1], comparator)) return false;
return true;
}
//打印方法
// print array to standard output
private static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.println(a[i]);
}
}

public static void main(String[] args) {
String[] a = StdIn.readAllStrings();
Insertion.sort(a);
show(a);
}
}