数据结构与算法(JAVA)-简单排序

简单排序包括冒泡排序，选择排序，插入排序三种排序方法，是入门级的排序，也是几种高级排序的基础。

比如高级排序中的希尔排序是基于插入排序来延伸的。

 

为实现排序代码，提前建立一个基类，将排序之外的细节先进行封装，下面的代码只关注具体的排序方法，基类代码如下：

 

package algorithms.simpleSort; /*** * * @author mudalu * */ public abstract class ArraySimple { protected long[] a;//待排序队列 protected int nElems;//队列长度 /** * * @param maxLength 要初始化的队列长度 */ public ArraySimple(int maxLength){ a = new long[maxLength]; nElems = 0; } /*** * 插入方法 * @param value 插入的值 */ public void insert(long value){ a[nElems] = value; nElems++; } /*** * 打印方法 */ public void display(){ for(int i = 0; i <= nElems-1; i++){ System.out.println(a[i]); } } /*** * 排序方法，由实现类实现不同的排序方法 */ public void sort(){ } /*** * 位置交换方法 * @param one * @param two */ public void swap(int one, int two){ long temp; temp = a[one]; a[one] = a[two]; a[two] = temp; } /*** * 位置交换方法 * @param one */ public void swap(int one){ swap(one, one+1); } }  

 

为方便描述几种简单排序方法，首先进行一个场景设定，假设一个棒球队的成员无规则的一字排开，然后我们假定这就是我们要排序的一组内容，并分别使用三种排序方法对棒球队按从高到矮进行排序。

未排序状态下的棒球队

 

已排序状态下的棒球队

 

 

1.冒泡排序

 

1.1  执行例程  

从队列的最左边开始，先比较0号位置和1好位置的队员，如果0号位置队员比1号位置队员高，则将两个队员的位置调换，反之则保持位置不变；然后比较1号位置和2号位置的队员，如果1号位置的队员比2号位置的队员高，则将两个队员的位置调换，反之则保持位置不表；由此规律继续向后进行，直到最后。

 

冒泡排序：第一次排序过程

 

 

此次过程的结果会将最高的队员转移到队伍的最右侧

冒泡排序：第一次排序结果

 

之后进行第二次排序过程，从头再次执行例程，因为最右侧为已排序队列，所以第二次执行的终点是倒数第二个位置，结果是将第二高的队员转移到右侧第二个位置。

由此类推，每执行一次例程，则将未排序队列中(左侧)的最高队员转移到已排序队列中(右侧)，最后达到排序的结果。

 

1.2  代码

 

package algorithms.simpleSort; public class ArrayBub { private long[] a;//待排序队列 private int nElems;//队列长度 public ArrayBub(int maxLength){ a = new long[maxLength]; nElems = 0; } public void insert(long value){ a[nElems] = value; nElems++; } public void display(){ for(int i = 0; i <= nElems-1; i++){ System.out.println(a[i]); } } /* * 冒泡排序 */ public void bubbleSort(){ int out = nElems - 1;//计算队列最大长度 int in = 0; for(;out >= 0; out--){//外层循环，每次循环后右侧的已排序队列将+1，所以左侧要-1 for(;in < out; in++){//内层循环，用于比较和交换 if(a[in] > a[in+1])//相邻队员进行比较 swap(in);//如果左侧队员比右侧队员高，则交换位置 } in = 0;//每次循环后再从头开始比较 } } public void swap(int one, int two){ long temp; temp = a[one]; a[one] = a[two]; a[two] = temp; } public void swap(int one){ swap(one, one+1); } } 

 

package algorithms.simpleSort; public class SimpleSortMain { /** * @param args */ public static void main(String[] args) { ArraySimple bub = new ArrayBub(7); bub.insert(8); bub.insert(4); bub.insert(1); bub.insert(9); bub.insert(11); bub.insert(8); bub.display(); bub.sort(); System.out.println("/n"); bub.display(); } } 

 

1.3  效率分析

从代码上来看，由于对队列进行两次嵌套循环，所以时间复杂度为O(N2)，而且比较次数是每次都进行比较为O(N2)，交换的次数平均为O(N2)/2，不过需要的辅助存储空间是固定的为O(1)。

 

2.选择排序

2.1  执行例程

顾名思义，选择排序就是先在队列中选择一个期待的值后再进行排序。

还是以不规则棒球队为例子，首先在队列中遍历一遍，找出最矮的队员将其个最左侧队员进行位置交换，这时最左侧为最矮的队员；然后从左侧第二位队员开始遍历找出最矮的队员，将其和左侧第二位队员进行位置交换。后面按此规则依次进行遍历和交换操作直到最后。

选择排序过程

 

从选择排序的过程来看，左侧是已排序队列，右侧是待排序队列。

 

2.2  代码

 

package algorithms.simpleSort; public class ArraySel extends ArraySimple { public ArraySel(int maxLength) { super(maxLength); } /* * 选择排序 */ public void sort(){ int in;//内层索引 int outer;//外层索引 int min;//每次循环后的最小值索引 for(outer = 0; outer <= nElems-1; outer++){//外层循环，每次循环后已排序队列+1 min = outer;//将第一个未排序项索引设定为最小项目 for(in = outer; in <= nElems-1; in++){//内层循环进行最小值查询遍历 if(a[in] < a[min])//判断最小值 min = in;//设置最小值 } swap(outer,min);//最小值项和首个项进行交换 } } }  

 

package algorithms.simpleSort; public class SimpleSortMain { /** * @param args */ public static void main(String[] args) { ArraySimple bub = new ArraySel(7); bub.insert(8); bub.insert(4); bub.insert(1); bub.insert(9); bub.insert(11); bub.insert(8); bub.display(); bub.sort(); System.out.println("/n"); bub.display(); } } 

 

2.3  执行效率

在代码中很明显也可以看出是两个嵌套循环构成的排序代码，所以对于时间复杂度来说也应该是O(N2)，不过仔细观察可以发现，比较次数虽然和冒泡排序相同也是O(N2)，但是交换次数是在外层嵌套里，也就是说交换次数降低了一个级数为O(N)，所以说，对于交换成本较大的对象来说，选择排序比冒泡排序效率更高一些。

辅助存储和冒泡基本相同，也是O(1)。

 

3.插入排序

3.1执行例程

首先将队列中一名队员A[n]进行标记，假设A[n]之前的队列为有序队列，将A[n]移出队列，用其和左边有序队列进行遍历比较，直到找到第一个比A[n]矮的队员A[m]，这时将有序队列中的A[m+1]到A[n-1]部分整体向右移动一个位置，再将A[n]插入到A[m+1]的位置，A[n]后面的无序队列中每个队员由此类推进行比较插入排序，最后达到整个队列的全排序。

 

插入排序过程

 

 

 

3.2代码

 

package algorithms.simpleSort; public class ArrayIns extends ArraySimple { public ArrayIns(int maxLength) { super(maxLength); } /*** * 插入排序 */ public void sort(){ int m;//有序队列索引 int n = 1;//被标记对象索引 for(;n <= nElems-1;n++){ long temp = a[n];//移出被标记对象 m = n -1;//有序队列最后一位 while(m >= 0 && temp < a[m]){//A[n]对有序队列遍历查询 a[m+1] = a[m];//右移操作 --m;//有序队列中的下一个对象 } a[m+1] = temp;//将A[n]插入到A[m+1]的位置 } } } 

 

package algorithms.simpleSort; public class SimpleSortMain { /** * @param args */ public static void main(String[] args) { ArraySimple bub = new ArrayIns(7); bub.insert(8); bub.insert(4); bub.insert(1); bub.insert(9); bub.insert(11); bub.insert(8); bub.display(); bub.sort(); System.out.println("/n"); bub.display(); } }

 

3.3执行效率

插入排序需要多少次比较和交换次数呢？第一次排序，最多需要一次比较和一次交换，第二次排序，最多需要两次比较和两次排序，以此类推，最后一次需要N-1次，因此有：

1+2+3+...N-1=N*(N-1)/2

然而每一次排序发现插入点之前，平均只有全部数据项的真的进行了比较和交换，除以2得到：N*(N-1)/4

所以插入排序的比较和交换的时间复杂度均为O(N2)/2，所以它比冒泡排序要快一倍，比选择排序也要略快一些。