数组排序

冒泡排序

　　规则：

　　1、比较相邻的两个数

　　2、如果左边的大，则交换位置

　　3、向右移动一位，比较下一位

　　当所有的数都进行一遍这个规则时，得到最大的数放在最右边。然后重新回到最左端，循环剩下的N-1个数，依次循环。

选择排序：

　　规则：

　　1、指定一个数作为比较标准，跟其他数进行比较，得到最小的数

　　2、交换最小数和该标准数的位置

　　3、从剩下的数中，再选取一个数作为标准，依次和其它数比较，得到下一个最小数

　　4、交换该最小数和标准数的位置

　　5、重复第3~4步

插入排序：

　　图示：

　　

奇偶排序：

　　规则：

　　1、把所有的奇数列的元素与其右相邻元素比较，交换大小，小的在左

　　2、把所有的偶数列的元素与其右相邻元素比较，交换大小，小的在左

　　3、循环前两步

java代码实现：

package com.luwen;

import java.util.ArrayList;
import java.util.List;

public class Test2 {

    public static void main(String[] args) {
        
        OrderArray arr = new OrderArray(6);
        
        arr.insert(12);
        arr.insert(2);
        arr.insert(10);
        arr.insert(2);
        arr.insert(5);
        arr.insert(20);

        arr.display();
        
//        arr.bubbleSort();
//        arr.display();
        
//        arr.selectSort();
//        arr.display();
        
//        arr.insertSort();
//        arr.display();
        
        arr.oddEvenSort();
        arr.display();
    }
}


class OrderArray{
    private long[] a; //数组
    private int nElems;  //数组下标
    
    public OrderArray(int max){
        a = new long[max]; //初始化数组
        nElems = 0;
    }
    
    /**
     * 返回数组的长度
     * @return
     */
    public int size(){
        return nElems;
    }
    
    /**
     * 添加数组元素
     * @param value
     */
    public void insert(long value){
        a[nElems] = value;
        nElems++;
    }
    

    /**
     * 冒泡排序
     */
    public void bubbleSort(){
        for (int i = 0; i < nElems; i++) {  // 外层循环
            for (int j = 0; j < nElems-1-i; j++) {  // 内层循环，每次循环找到一个最大值排在最后,排好的数不参与下次排序
                if(a[j]>a[j+1]){
                    // 互换位置
                    long k = a[j];
                    a[j] = a[j+1];
                    a[j+1] = k;
                }
            }
        }
    }
    
    /**
     * 选择排序
     */
    public void selectSort(){
        // 挑出最小的数，放到第一个位置
        int k;
        for (int i = 0; i < nElems; i++) {
            // 每次要比较的值的下标
            k = i;
            // 得到最小值
            for (int j = i; j < nElems; j++) {
                if(a[j]<a[k]){
                    k = j;  // 得到最小值的下标
                }
            }
            // 交换位置 
            long v = a[k];
            a[k] = a[i];
            a[i] = v;
        }
        
    }
    
    /**
     * 插入排序
     */
    public void insertSort(){
        for (int i = 1; i < nElems; i++) {
            if(a[i]<a[i-1]){
                // 要求前面元素有序
                // 将a[i] 插入到前面的j个元素中
                for (int j = 0; j < i; j++) {
                    // 找出a[i]要插入的位置
                    if(a[i]<a[j]){
                        long v = a[i];
                        delete(i);
                        // 将a[j]往后移一位
                        for (int k = nElems-1; k > j; k--) {
                            a[k] = a[k-1];
                        }
                        // 插入
                        a[j] = v;
                    }
                }
            }
        }
        
        // 方法二
        /*for (int i = 1; i < nElems; i++) {
            long temp = a[i];
            while(i>0 && a[i-1]>=temp){
                a[i] = a[i-1];
                --i;
            }
            a[i] = temp;
        }*/
        
    }
    
    /**
     * 奇偶排序
     */
    public void oddEvenSort(){
        for (int i = 1; i < nElems-1; i+=2) {
            for (int j = 0; j < nElems-1; j+=2) {
                if(a[i]>a[i+1]){
                    long v = a[i];
                    a[i] = a[i+1];
                    a[i+1] = v;
                }
                if(a[j]>a[j+1]){
                    long v = a[j];
                    a[j] = a[j+1];
                    a[j+1] = v;
                }
            }
        }
    }
    
    /**
     * 删除该位置上的值
     * @param value
     * @return
     */
    public void delete(int index){
        List<Long> list = new ArrayList<Long>();
        for (int i = 0; i < nElems; i++) {
            if(i!=index){
                list.add(a[i]);
            }
        }
        long arr[] = new long[nElems];
        Object []obj = list.toArray();
        for (int i = 0; i < obj.length; i++) {
            arr[i] = (long) obj[i];
        }
        a = arr;
    }
    
    /**
     * 查看数组
     */
    public void display(){
        for (int i = 0; i < nElems; i++) {
            System.out.print(a[i]+ " ");
        }
        System.out.println("");
    }
    
}

效率问题：

　　eg:10个随机数，

　　冒泡排序：

　　需要进行9+8+7+6+5+4+3+2+1=45次比较过程。

        即. (N-1)+(N-2)+(N-3)+...+1 = N*(N-1)/2   当数据项很大时，比较次数近似为N^2/2，而交换次数为N^2/4(需不要需要交换是随机的，符合0-1分布)，在大O表示法中，为O(N^2)。表示交换和比较的次数和数据项的平方成正比；数据项越大，比较耗时越大。

　　选择排序：

　　需要进行9+8+7+6+5+4+3+2+1=45次比较过程。但，只需要最多9次的交换。

　　当数据项很大时，次数成效率的主要因素，因此选择排序也是O(N²)时间。在N较小时，选择排序较快

　　插入排序：

　　需要进行1+2+3+4+5+6+7+8+9=45次比较

 　　当数据部分有序时，方法二的while循环基本为假，这时插入排序只执行需要O(N)的时间