奇偶排序

有一种简单排序算法是奇偶排序。
思路是在数组中重复两趟扫描。第一趟扫描选择所有的数据项对，a[j]和a[j+1]，j是奇数。如果他们的关键字的值次序颠倒就交换他们。第二趟扫描对所有的偶数数据项进行同样的操作，j是偶数。重复进行这样的两趟的排序直到数组全部有序。

Java实现：

public class ArrayOddEven {
    private long[] a;
    private int nElems;
    public ArrayOddEven(int max) {
        a = new long[max];
        nElems = 0;
    }
    public void insert(long value) {
        a[nElems] = value;
        nElems++;
    }
    public void display() {
        for(int j=0; j<nElems; j++) {
            System.out.print(a[j] + " ");
        }
        System.out.println("");
    }

    public void oddEvenSort() {
        int num = 0;
        while(!isOrder()){
            for(int j=1; j<nElems-1; j+=2) {
                if(a[j]>a[j+1]) {
                    swap(j, j+1);
                }
            }
            for(int j=0; j<nElems-1; j+=2) {
                if(a[j]>a[j+1]) {
                    swap(j, j+1);
                }
            }
            num++;
        }
        System.out.println("Sort times: " + num);
    }
    private boolean isOrder() {
        boolean b = true;
        for(int j=0; j<nElems-1; j++) {
            if(a[j+1]<a[j]) {
                b = false;
            }
        }
        return b;
    }
    private void swap(int in, int i) {
        long temp;
        temp = a[in];
        a[in] = a[i];
        a[i] = temp;
    }
}

测试：

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

        arr.insert(77);
        arr.insert(99);
        arr.insert(55);
        arr.insert(22);
        arr.insert(88);
        arr.insert(44);
        arr.insert(11);
        arr.insert(00);
        arr.insert(66);
        arr.insert(33);

        arr.display();

        arr.oddEvenSort();

        arr.display();
    }
}

测试结果：
77 99 55 22 88 44 11 0 66 33
Sort times: 4
0 11 22 33 44 55 66 77 88 99

奇偶排序实际上在多处理器环境中很有用，处理器可以分别同时处理每一个奇数时，然后又同时处理偶数对。因为奇数对是彼此独立的，每一对都可以用不同的处理器比较和交换，这样可以非常快速的排序。