常用的排序

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存，排序作为最常用的算法之一掌握几种最常用的是有必要的。

---

简单排序

基本思想：用第一个数字和所有数字比较替换，因为替换的是第i个数字所以就继续比较就好。

    public void sort0(int[]values){
        for(int i=0;i<values.length;i++){
            for(int j=i+1;j<values.length;j++){
            //第i个数字小于比较的数字，就替换位置
                if(values[i]>values[j]){
                    int temp = values[i];
                    values[i]=values[j];
                    values[j]=temp;
                }
            }
        }
    }

冒泡排序

基本思想：用相邻的两个值一直比较，一次下来最后一位数 就会得到最大或者最小的值

    public void sort00(int[]values){
        for(int i=0;i<values.length;i++){
            for(int j=0;j<values.length-i-1;j++){
            //两个相邻的数前面的比后面的大，就替换位置
                if(values[j]>values[j+1]){
                    int temp = values[j];
                    values[j]=values[j+1];
                    values[j+1]=temp;
                }
            }
        }
    }

插入排序

基本思想：类似于一张一张插入扑克牌,每插一张牌顺序都是排好的。

    public void  sort1(int[]values){
        int lengt =values.length;
        int j=0; //表示要被temp替换下标
        for(int i=1;i<lengt;i++){
            int temp = values[i];//需要插入的值，这个值已经被拿出来了后面随便玩儿。
            j=i;
            while(j>0){
                if(temp<values[j-1]){   //当temp小于前一个的时候就发生替换,一个挪位置的过程。
                    values[j]=values[j-1]; 
                    j--;
                }else{      //当temp的值比左边的最大值还大就没必要继续插入了
                    break;
                }
            }
            values[j]=temp;       //把temp的填入
        }
    }

快速排序

基本思想： 一个从左向右查找(寻找大于temp的值)，一个从右向左查找各（寻找小于temp的值）一次。注意：temp是取的第一个值即是左边的值，所以从右边先开始。
左边开始大于temp的值放入右边（下标J），右边开始小于temp的值放入左边（下标i）。
一次下来的效果就会是 temp左边的值比temp小，temp右边的值比temp大；
一次下来的效果： temp-1，temp-4，temp-n，temp，temp+n,temp+2,temp+4 以temp为中心分为两半

    //一次操作的算法
    public int sort2(int[]values,int start,int end){
        int temp = values[start];
        int i=start,j=end;
        while(i<j){
            //从右向左 <----
            while(true){
                if(values[j]<temp){
                    values[i]=values[j];    //发生替换就不继续找了
                    break;
                }
                if(i==j){               // i、j重合表示已查找完毕
                    break;
                }
                j--;
            }
            //从左向右 ---->
            while(true){
                if(values[i]>temp){
                    values[j]=values[i];  //发生替换就不继续找了
                    break;
                }
                if(i==j){                 // i、j重合表示已查找完毕
                    break;
                }
                i++;
            }
        }
        values[i]=temp;         //这部很关键 要把当初得到的值回填。
        return i;
    }

    //把分下来的左右两边进行递归运算（一种分治的思想）
    public void go(int[]array,int start,int end){
        if(start>=end){
            return ;
        }
        int middle = sort2(array, start, end);
        go(array, start, middle-1);//左边的（底值）
        go(array, middle+1, end);  //右边的 （高值）
    }

总结

个人认为当数据量较大时采用快速排序最好，而数据量较小时什么排序简单就按什么来呗反正数据量小。