排序算法实际应用

最近 工作中 碰到这么一个场景：
我们需要统计合伙人这个月的所有的收入和开支明细，并且按时间进行降序排列
这些数据分别存在 不同的数据表中中，而且有些数据 例如订单信息 需要多返回一些字段 提供前端进行计算
所以，无法用一个sql语句进行 查找，只能用多条sql语句进行查找
那这样就会带来一个问题:
那就是对时间进行降序排列：
我的方案是：对每条sql 语句首先先进行时间排序，不同sql语句查找出来的内容都用List<Map<String,Object>> 进行封装
接下来就是 算法的问题了：
是先把 所有的list 放到一起进行，再进行排序呢，还是逐个逐个合并同时直接进行排序呢。

我首先 先用 选择 所有的放到一起进行排序

1.选用二分排序算法：

package suanfa;
/**
 * 二分排序 其实并不是一种新的算法
 * 刚开始会先构建一个有序区，随后把后面无序区的数值一个个 通过二分查找找到 比这个值大的的坐标（例如是3），那么这个值的下标就是2
 * 把有序区从2开始的数组都往后挪
 * 把无序区的这个值插进去
 * @author Minzhe Xu    2017年4月25日上午9:41:42
 *
 */
public class ErFen {
     public static void main(String[] args) {
            int []a={4,2,1,6,3,6,0,-5,1,1};
            int i,j;
            int low,high,mid;
            int temp;
            for(i=1;i<10;i++){
                temp=a[i];
                low=0;
                high=i-1;
                while(low<=high){
                    mid=(low+high)/2;
                    if(a[mid]>temp)//拿临时的值与中间值进行比较，比他小，说明 下标应该比中间值的下标小
                        high=mid-1;
                    else
                        low=mid+1;  
                }
                for(j=i-1;j>high;j--)
                    a[j+1]=a[j];//a[i]=a[i-1]  //数组向后扩容  直到遇到high下标为止

                a[high+1]=temp;//a[i-1]=temp     空出来的这个  节点插入
            }
            for(i=0;i<10;i++){
                System.out.printf("%d ",a[i]);
            }
        }

}

二分搜索比顺序搜索查找快,所以二分插入排序就平均性能来说比直接插入排序要快。
它所需的排序码比较次数与待排序对象序列的初始排列无关,仅依赖于对象个数。在插入第i个对象时,需要经过log2i+1次排序码比较,才能确定它应插入的位置。 将n个对象用折半插入排序所进行的排序码比较次数比较次数(KCN)：∑n−1(log2i+1)≈nlog2n
二分插入排序是一个稳定的排序方法。
当n较大时,总排序码比较次数比直接插入排序的最坏情况要好得多,但比其最好情况要差。
在对象的初始排列已经按排序码排好序或接近有序时,直接插入排序比折半插入排序执行的排序码比较次数要少。折半插入排序的对象移动次数与直接插入排序相同,依赖于对象的初始排列。

下面是对List的降序排列

private void sortByTime(List<Map<String, Object>> listAll) {
        int i,j;
        int low,high,mid;
        Map<String, Object>  temp;
        for(i=1;i<listAll.size();i++){
            temp=listAll.get(i);
            Date tempObject=(Date) temp.get("f_time");
            low=0;
            high=i-1;
            while(low<=high){
                 mid=(low+high)/2;
                 Date midObject=(Date) listAll.get(mid).get("f_time");
                 if(midObject.getTime()<tempObject.getTime()){
                     high=mid-1;
                 }else{
                     low=mid+1;
                 }
            }
            for(j=i-1;j>high;j--){
                listAll.set(j+1,listAll.get(j));
                listAll.set(high+1, temp);

            }
        }

    }

500多条数据 总共耗时500ms
性能上还不明显，接下来会做更多的测试

2.插入排序的选用
首先先介绍算法

/**
 * 插入排序
 * 从第一个元素开始，该元素可以认为已经被排序取出下一个元素，
 * 在已经排序的元素序列中从后向前扫描如果该元素小于前面的元素（已排序），
 * 则依次与前面元素进行比较如果小于则交换，
 * 直到找到大于该元素的就则停止；
 * 如果该元素大于前面的元素（已排序），
 * 则重复步骤2重复步骤2~4 直到所有元素都排好序 。
 * @author Minzhe Xu    2017年4月1日下午1:06:22
 *
 */
public class Insertion {
    public static void main(String[] args) {
        int a[]={1,2,7,5,8,0,4,6,2};

        for(int i=1;i<a.length;i++){

            for(int j=i;j>0&&(a[j]<a[j-1]);j--){//随着i的增加 有序队列的容量每次都会加1，对新增加进有序队列的那个值  进行交换排序
                int temp=a[j];
                a[j]=a[j-1];
                a[j-1]=temp;
            }
        }
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }

算法还是蛮简单的，走一遍就知道了，下面看看实际的应用

//对listAll中的时间进行排序
private void sortByInsertion(List<Map<String, Object>> listAll) {
        Map<String, Object>  temp;
        for(int i=1;i<listAll.size();i++){
            for(int j=i;j>0;j--){
                Date date_J = (Date) listAll.get(j).get("f_time");
                Date date = (Date) listAll.get(j-1).get("f_time");
                if(date_J.getTime()<date.getTime()){
                    //交换
                    temp=listAll.get(j-1);
                    listAll.set(j-1, listAll.get(j));
                    listAll.set(j, temp);
                }
            }
        }
    }

实际应用中 发现在1000条数据的情况下上述两种的算法差距并不明显，不过针对上述的情况，推荐使用 插入排序。
未完待更新