排序操作

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


public class sortMethods {
    
    
    //插入排序：每次拿出第i个元素，并将其与之前已经排好序的数组进行比较，找到插入的位置，对于已经排好序的数组来说，算法复杂度为o(n)，对于倒序的数组来说，算法复杂度为o(n^2);
    //单纯的线性查找，而是还要移出一个空位让A[i]插入，因此就算二分查找用O(lgn)查到了插入的位置，但是还是要用O(n)的时间移出一个空位。
    public double[]InsertSort(double []datas){
        for(int i = 1;i<datas.length;i++){
            double key = datas[i];
            int j = i-1;
            while(j>0&&datas[j]>key){
                    datas[j+1]=datas[j];
                    j--;  
            }
            datas[j+1]=key;
        }
        return datas;
    }
    
    
    
    //快速排序O(nlog2n)
    //1、选取一个基准元素，通常为第一个元素，将数组datas分为三部分，第一部分为比key小的元素listmin，第二部分为key，第三部分为比key大的元素listmax，分别对listmin和listmax重复上述过程。
    public List<Double>  fastSort(List<Double> datas){
        double key = datas.get(0);
//        System.out.println(key);
        List<Double> listmin = new ArrayList<Double> ();
        List<Double>  listmax = new ArrayList<Double> ();
        for(int i = 1;i<datas.size();i++){
            if(datas.get(i)<=key){
                listmin.add(datas.get(i));
            }else{
                listmax.add(datas.get(i));
            }
        }
        if(listmin.size()>1){
            listmin=fastSort(listmin);
        }
        if(listmax.size()>1){
            listmax=fastSort(listmax);
        }
        List<Double>  sum = new ArrayList<Double> ();
        sum.addAll(listmin);
        sum.add(key);
        sum.addAll(listmax);
        return sum;
    }
    
    
    //冒泡排序O(n^2)
    //通过两两交换，像水中的泡泡一样，小的先冒出来，大的后冒出来。
    public List<Double>BubbleSort(List<Double> datas){
        int length = datas.size();
        for(int i = 0;i<length;i++){
            
            //每一次内循环之后，最小的放在了第i个位置
            for(int j = length-1;j>i;j--){
                if(datas.get(j)<datas.get(j-1)){
                    double temp = datas.get(j);
                    datas.set(j, datas.get(j-1));
                    datas.set(j-1, temp);
                }
            }
        }
        return datas;
    }
    
    
    //插入排序和冒泡排序的区别
    //渐进时间都是o(n^2);但是插入排序的速度是逆序对的个数，而冒泡排序中执行“交换“的次数是逆序对的个数，因此冒泡排序执行的时间至少是逆序对的个数，因此插入排序的执行时间至少比冒泡排序快。
    
    
    
    //选择排序:每次找一个最小值。o(n^2)
    public List<Double>SelectSort(List<Double> datas){
        for(int i = 0;i<datas.size()-1;i++){
            int min = i;
            for(int j = i+1;j<datas.size();j++){
                if(datas.get(min)>datas.get(j)){
                    min = j;
                }
            }
            double temp  = datas.get(i);
            datas.set(i, datas.get(min));
            datas.set(min, temp);
        }
        return datas;
    }
    
    
    
    
    
    //计数排序
    
}