排序

public class Sort {
    /**
     * @param data
     * 冒泡排序  比较接近选择排序,不同的是冒泡排序一直在交换,而选择排序是不断比较,
     * 直到确定正确的下标一次交换完成
     */
    public void bubble_sort(int[] data) {
        int temp;
        for(int i=0; i<data.length; i++){
            //内层循环从后向前,找到最小值.循环终止时,最小值处于i位置
            for (int j=data.length-1; j>i; j--){
                if(data[j]<data[j-1]){
                    temp = data[j-1];
                    data[j-1] = data[j];
                    data[j] = temp;
                }
            }
        }        
    }
    

    
    /**
     * 插入排序  固定元素找位置
     * @param data 手中有data.length张牌,从第二张牌开始直到最后一张牌
     * 插入前面已经排好序的牌中,程序中的j起到遍历之前已排好序的牌的作用
     */
    public void insert_sort(int[] data) {
        int key,j;
        for(int i=1; i<data.length; i++){
            key = data[i];
            j= i-1;
            //key相当于data[j+1],因为0~j数据都是有序的,key只要比j大
            //则比0~j都要大
            while(j>=0 && key<data[j]){
                data[j+1] = data[j];//可以理解为元素向后移动
                j--;
            }            
            data[j+1] = key;
        }    
    }

    
    /**
     * 选择排序 固定位置找元素
     * @param data
     */
    public void selection_sort(int[] data) {
        int smallest,temp;
        for(int i=0; i<data.length-1; i++){
            smallest = i;
            for(int j=i+1; j<data.length; j++){
                if(data[j] < data[smallest]){
                    smallest = j;
                }
            }
            
            temp = data[i];
            data[i] = data[smallest];
            data[smallest] = temp;
        }        
    }
    
    
    /**归并排序
     * @param data
     */
    public void  merge_sort(int[] data){
        merge_sort(data, 0, data.length-1);
    }    
    private void merge_sort(int[] data, int p, int r) {
        //这段代码可这样理解:
        //一个大数组传入,被分成两半,两半数组分别传入
        //再又被分成两半,直到每一半只有一个元素
        //然后开始合并        
        if(p<r){
            int q = (p+r)/2;
            merge_sort(data,p,q);
            merge_sort(data,q+1,r);
            merge(data,p,q,r);
        }
    }
    private void merge(int[] data, int p, int q, int r) {
        
        //新建数组L,R
        //L保存原数组p~q元素
        //R保存原数组q+1~r元素
        int L[] = new int[q-p+1];
        int R[] = new int[r-q];
        System.arraycopy(data, p, L, 0, L.length);
        System.arraycopy(data, q+1, R, 0, R.length);
        
        //变量k的作用在于将原数组p~r位置的元素按从小到大顺序重排
        //i,j分别用来遍历左右数组
        int i=0;
        int j=0;
        int k;
        for(k=p; k<=r; k++){
            if(L[i]<=R[j]){
                data[k] = L[i];
                i++;
                //数组到头,循环结束
                if(i==L.length){
                   break;
                }
            }else{
                data[k] = R[j];
                j++;
                if(j==R.length){
                    break;
                }
            }
        }
        //当某个数组遍历完,考虑到两个子数组都是有序的
        //只需要将另外一个数组的剩余值全部复制到原数组
        //上面循环退出时,k位置已经被赋值,所以是++k
        //另一个数组的赋值却未能执行,所以是i(j)++
        while(i<L.length){
            data[++k] = L[i++];
        }
        while(j<R.length){
            data[++k] = R[j++];
        }
        
    }


    
    /**
     * 快速排序
     * @param data
     */
    public void quick_sort(int[] data){
        quick_sort(data, 0, data.length-1);
    }
    private void quick_sort(int[] a, int p, int r){
        if(p < r){
            int q = partition(a, p, r);
            quick_sort(a,p,q-1);
            quick_sort(a,q+1,r);
        }        
    }
    /**
     * @return  
     */
    private int partition(int[] a, int p, int r){
        int i = p-1;
        int x= a[r];
        int temp;
        //选最后一个数字作为比较对象，方便for循环书写，中间没有被隔断
        for (int j = p ; j<r; j++){
            if(a[j] <= x){
                i = i+1;
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        temp = a[i+1];
        a[i+1] = a[r];
        a[r]  = temp;
        return i+1;
        //j用来遍历数组,i用来标记将要发生交换的位置
    }
    

}