Java数据结构与算法--简单排序

简单排序

本文讨论比较简单的排序算法：冒泡排序、选择排序、插入排序

三个算法都包括如下两个步骤。

• 比较两个数据项
• 交换两个数据项、或复制其中一项。

冒泡排序

冒泡排序算法运行起来非常慢，但是在概念上他是排序算法中最简单的。

冒泡排序遵循的规则：
1. 比较两个数据
2. 如果左边的数据大，则两个数据交互位置。
3. 向右移动一个位置，比较下面两个数据。（沿着这个队列一直比较下去，一直比较到队列的最右端），这时最右端的数据应该会是最大的数。
4. 当碰到第一个排定的数据后，就返回队列的左端重新开始下一趟排序。
代码实现

/**
 * 冒泡排序
 */
public class BubbleSort {
    //初始化数组
    private static long a[]=new long[]{11,4,7,9,2,10,23,8,34,29};
    //数组长度
    private static int nElems=a.length;
    public static void main(String[] args) {
        int in,out;
        for (out=nElems-1;out>1;out--){ //
            for (in=0;in<out;in++){ 
                //比较相邻的元素。如果第一个比第二个大，就交换他们两个。
                if (a[in]>a[in+1]){
                    swap(in,in+1);
                }
            }
        }
        //输出排序
        for (long l:a){
            System.out.print(l+" ");
        }
    }
    //交换数据
    private static void swap(int in, int i) {
        long temp=a[in];
        a[in]=a[in+1];
        a[in+1]=temp;
    }

算法思路
１.将最小的数据项放在数组的最开始，并将最大的数据项放在数组的最后。
２.外层for 循环的计数器out从数组的最后开始，没经过一次循环ｏｕｔ减一。下标大于ｏｕｔ的数据项都是已经排好序的，变量ｏｕｔ每完成一次内部循环（计数器为ｉｎ）后就左移一位。
３.内层ｆｏｒ循环计数器ｉｎ从数组的最开始算起（ｉｎ＝０），没完成一次内部循环体加一，当它等于ｏｕｔ时结束一次循环，在内层ｆｏｒ循环体重，数组下标ｉｎ和ｉｎ＋１的两个数据项进行比较，如果ｉｎ数据大于ｉｎ＋１数据项，则交换数据。
４.为了清晰增加独立的ｓｗａｐ（）方法执行交换，但是它会增加一些额外的消耗，如果自己使用排序程序，最好将交换操作这段代码直接放到程序中。这样可以提高一些速度。

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法

代码实现

/**
 * Created by YcDr on 2017/5/24.
 * 选择排序
 */
public class SelectSort {
    //初始化数组
    private static long a[]={12,34,19,2,54,13,11,33,18,9};
    //数组长度
    private static int nElems=a.length;

    public static void main(String[] args) {
        int in,out,temp;
        for (out=0;out<nElems;out++){
            temp=out;//temp临时变量，用于存取最小值下标
            for (in=out+1;in<nElems;in++){
                    if (a[temp]>a[in]){
                        temp=in;
                    }
            }
            //每次循环找出最小值下标后，在进行数据交换
            swap(out,temp);
        }

        for (long l:a)
            System.out.print(l+" ");
    }
    //交换数据
    private static void swap(int i,int t) {
        long temp=a[t];
        a[t]=a[i];
        a[i]=temp;
    }
}

与冒泡排序比较

选择排序与冒泡排序相比，都执行了相同的比较次数N*(N-1)/2,但是相比冒泡排序，选择排序降低了交换数据的次数。

选择排序和冒泡排序一样运行了O（N^2）时间，但是显然选择排序要比冒泡排序更快一些，因为选择排序交换次数很少，如果交换时间及比比较时间及要大的多时，选择排序实际要快的多。

插入排序

在大多数情况下，插入算法是本章描述的基本排序算法中最后的一种，虽然插入排序算法任然需O(N^2) 的时间，但是在一般情况下他要比冒泡排序快一倍，比选择排序还要快一点。

算法思路
1. 默认序列中的第0个元素是有序的；
2. 从下标为1（下标从0开始）的元素开始，取当前下标i位置处的元素a[i]保存到一个临时变量里；
3. 对前半部分有序序列的循环遍历，并与临时变量比较，直到遇到一个比临时变量小的元素（这里默认是从小到大排序），交换数据
4. 将待插入元素的下标 i 向后推移一个位置；
5. 重复进行第2步到第4步，直到乱序序列中的元素被全部插入到有序序列中；

代码实现

/**
 * Created by YcDr on 2017/5/25.
 * 插入排序
 */
public class InsertSort {
    //初始化数组
    private static long a[]={12,19,34,2,54,13,11,33,18,9};
    //数组长度
    private static int nElems=a.length;

    public static void main(String[] args) {
        int in,out;
        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;
        }

        for (long l:a){
            System.out.print(l+" ");
        }
    }
}

稳定性

有些时候，排序要考虑数据项拥有相同关键字的情况，例如，雇员姓名按字典进行排序，现在又想按邮政编码排序，并希望，让不需要排序的数据保持原来的排序。这种情况下，则只需要算法对需要排序的数据进行排序，让不需要的数据保持原来的顺序，某些算法满足这样的要求，他们就可以称为稳定的算法。