算法—排序（快排，冒泡）

1.快速排序 

首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法。也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

代码如下：

import java.util.Arrays;
public class Test {
    public static void main(String args[]){

        //目标数组
        int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
        System.out.println(Arrays.toString(a));
        //调用方法
        quickSort(a, 0, a.length-1);
    }

    private static void quickSort(int a[],int l,int r){

        int i = l;  //用来存储开始的位置
        int j = r;  //用来存储结束的位置
        int temp = a[l]; //以数组第一个值作为中轴值

        //判断左右两侧开始查找是否相交
        while(l<r){
            //从右侧开始查找  判断是否相交 判断当前值是都大于中轴值  大于则继续查找
            while(l<r&&a[r]>temp){
                r--;
            }
            //如果不想交相交 且当前值小于中轴值  则将此位置的值付给中轴值
            if(l<r){
                a[l] = a[r];
                l++;
            }
            
            //从右侧开始查找  判断是否相交 判断当前值是都小于中轴值  小于则继续查找
            while(l<r&&a[l]<temp){
                l++;
            }
            //如果不想交相交 且当前值大于于中轴值  则将此位置的值付给中轴值
            if(l<r){
                a[r] = a[l];
                r--;
            }
            
            //执完一边将中轴值赋值给最后一次变动的位置
            a[l] = temp;
            System.out.println(Arrays.toString(a));
        }
        //递归调用
        if(i<l-1)quickSort(a, i, l-1);  //继续排序中轴值前的数组
        if(l+1<j)quickSort(a, l+1, j);  //继续排序中轴值后的数组
    }
}

2.冒泡排序

冒泡排序算法的运作如下：（从后往前）

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

private static void bubbleSort(int a[]){
        int temp = 0;
        for(int i=a.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(a[j]>a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }