第三章 简单排序

一、概要
三种简单的排序：冒泡排序、选择排序、插入排序。

二、冒泡排序
假设由n个队员，并且根据所站的位置从左到右分别给每一个队员编号，从0到n-1。
冒泡排序的过程如下：
从队列的最左边开始，比较第0号和第1号，如果左边的队员比右边高，则交换两个队员。否则不做任何事。然后右移一个位置，比较第1号和第2号，重复上诉步骤，直到最后一个队员。这个属于第一轮冒泡，能够把最高的队员放在最右边。然后进行第二轮，依然从第0号开始，这一轮排序到n-2号队员。重复进行上诉操作，直到无需再排序了。

三、冒泡排序代码

class ArrayBub {
private long[] a;
private int nElems;

public ArrayBub(int max) {
a = new long[max];
nElems = 0;
}

public void insert(long value) {
a[nElems++] = value;
}

public void display() {
for(int i = 0;i < nElems;i++) {
System.out.print(a[i] + “ “);
}
}

//排序算法
public void bubbleSort() {
int out;
int in;

for(out = nElems -1;out > 1;out—)
for(in = 0;in < out;i++) {
if (a[in] > a[in+1])
swap(in, in+1);
}

private void swap(int one, int two) {
long temp = a[one];
a[one] = a[two];
a[two] = temp;
}
}

class BubbleSortApp {
public static void main(String[] args) {
int maxSize = 100;
ArrayBub arr = new ArrayBub(maxSize);

arr. insert(77);
arr. insert(27);
arr. insert(71);
arr. insert(44);
arr. insert(23);
arr. insert(10);
arr. insert(87);
arr. insert(99);
arr. insert(32);

arr.display();

arr.bubbleSort();
arr.display();
}
}
冒泡算法的思路是要将最小的数据项放在数组的最开始（下标为0），并将最大的数据项放在数组的最后（下标为nElems-1），内层从数组的最开始算起，每次循环加一进行比较排序，外层从nElems-1开始，每次循环减一进行每一轮排序。

四、不变性
在许多算法中，有些条件在算法执行时时不变的。这些条件称为不变性。在冒泡算法中，它的不变性就是out右边的所有数据项是有序的。
在调试算法的时候，我们可以反复检查它的不变性是否为真，如果不是，就说明出错了。

五、冒泡排序的效率
可以发现，如果有n个数据项，第一趟排序中有n-1次比较，第二趟排序中有n-2次比较，如此类推：
(n-1)+(n-2)+(n-3)+…+1=n*(n-1)/2
与n平方成正比，因此冒泡排序的效率为O(N^2)

六、选择排序
同样是为球队排序，排序从球员队列的最左边开始，记录下最左边球员的身高，然后开始用下一个的球员身高和它相比较，如果这个球员更矮，则纪录下新的最矮纪录，然后继续看下一个球员，直到全部球员比较结束。然后纪录到身高最矮的球员和最左边的球员调换位置。接下来，从第二个球员开始，重复上诉步骤，直到最后一个球员。

七、选择排序代码

class ArraySel {

private long[] a;
private int nElems;

public ArraySel(int max) {

a = new long[max];
nElems = 0;
}

public void insert(long value) {
a[nElems++] = value;
}

public void display() {
for(int i = 0;i < nElems;i++) {
System.out.print(a[i] + “ “);
}
}

//选择算法
public void selectionSort() {
int out;
int in;
int min;

for(out = 0;out < nElems-1;out++) {
min = out;
for(in = out+1;in < nElems;in++)
if (a[in] < a[min])
min = in;
swap(out, min);
}

}

private void swap(int one, int two) {
long temp = a[one];
a[one] = a[two];
a[two] = temp;
}

}

class SelectSortApp {
public static void main(String[] args) {
int maxSize = 100;
ArraySel arr = new ArraySel(maxSize);

arr. insert(77);
arr. insert(27);
arr. insert(71);
arr. insert(44);
arr. insert(23);
arr. insert(10);
arr. insert(87);
arr. insert(99);
arr. insert(32);

arr.display();

arr.selectionSort();

arr.display();
}

}

八、不变性
在选择排序中，下标小于或等于out的位置的数据项总是有序的。

九、选择排序的效率
选择排序改进了冒泡排序的缺点，将交换次数从O(N^2)减少到O(N)，但是比较次数仍然是O(N^2)，因此二者的时间效率相同，但是选择排序无疑是更快的。

十、插入排序
在大多数情况下，简单排序中，插入排序是最快的一种。
假设队伍前一半已经排序好了，这个时候，在队伍中间有一个作为标记的队员，TA左边的所有队员已经是有序的，这时只要找到“被标记”队员在左边有序队列中合适的位置，就可以了。因此，我们先让“被标记”队员站出来，和左边有序队伍中最右边的那个队员比较，如果“被标记”队员更矮，那么最右边的队员右移一位，然后“被标记”队员继续和有序队伍右边倒数第二个队员比较，同样的规则，直到发现被比较的队员比“被标记”队员要矮，那么此时空出来的位置就是“被标记”的队员的。按照这个规则，我们就是从队伍的第一个依次标记到最后一个。

十一、插入排序的代码

class ArrayIns {

private long[] a;
private int nElems;

public ArrayIns(int max) {

a = new long[max];
nElems = 0;
}

public void insert(long value) {
a[nElems++] = value;
}

public void display() {
for(int i = 0;i < nElems;i++) {
System.out.print(a[i] + “ “);
}
}

//插入算法
public void insertSort() {
int out;
int in;

for(out = 1;out < nElems;out++) {
long temp = a[out];
in = out;
while(in > 0 && a[in-1] >= temp) {
a[in] = a[in-1];
in—;
}
a[in] = temp;
}
}
}

class InsertSortApp {

public static void main(String[] args) {
int maxSize = 100;
ArraySel arr = new ArraySel(maxSize);

arr. insert(77);
arr. insert(27);
arr. insert(71);
arr. insert(44);
arr. insert(23);
arr. insert(10);
arr. insert(87);
arr. insert(99);
arr. insert(32);

arr.display();

arr.insertSort();

arr.display();
}

}

十二、插入排序中的不变性
插入排序中，比out下标小的数据项都是局部有序的。

十三、插入排序的效率
1+2+3+…+N-1=N*(N-1)/2，第一趟最多比较一次，第二趟最多比较两次。。。然而在每一趟排序发现插入点之前，平均只有全体数据项的一半真的进行了比较，因此应该是N*(N-1)/4。总体而言，插入排序的算法，比冒泡排序快一倍，比选择排序略快。