排序算法之交换排序（冒泡和快排）

交换排序的基本思想：两两比较待排序记录的关键字，发现两个记录的次序相反时
，进行交换，直到没有反序的记录为止。本篇介绍两种交换排序----冒泡排序和
快速排序。
 冒泡排序是一种经典的交换排序算法，基本思想是：通过无序区中相邻记录的关
 键字间的比较和位置的交换，使关键字最小的记录像气泡一样逐渐向上漂至水面
 。整个算法是从最下面的记录开始，对每两个相邻的关键字进行比较，把关键字
 较小的记录放到关键字较大的记录的上面，经过一趟排序后，关键字最小的记录
 到达最上面，接着再在剩下的记录中找关键字次小的记录，把它放在第二个位置
 上，依次类推，一直到所有记录有序为止。代码如下：

public class BubbleSort {
    public static void main(String[] args){
        int a[] = {2,3,4,6,5,7,9,1,8};
        bubbleSort(a, a.length);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }
    public static void bubbleSort(int a[],int n){
        int i,j, temp,exchange;
        for(i=0;i<n-1;i++){
            //exchange= 0;
            for(j = n-1;j>i;j--){   //比较，找出本趟最小的记录
                if(a[j]<a[j -1]){ 
                    temp = a[j];  //a[j]和a[j-1]交换，将最小的关键字记录前移
                    a[j] =a[j-1];
                    a[j-1] = temp;
                    //exchange=1;
                }
                //if(exchange==0){
                //  return;
                //}
            }
        }
    }
}

冒泡排序是一种稳定的排序算法，时间复杂度为O（n2）,空间复杂度为O(1)。 
快速排序是由冒泡排序改进来的，它的基本思想是：通过一趟排序将要排序的
数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据
都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可
以递归进行，以此达到整个数据变成有序序列。代码如下：

public class QuickSort {
    public static void main(String[] args){
        int a[] = {2,3,4,6,5,7,9,1,8};
        quickSort(a, 0,a.length-1);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }
    //从两头向中间扫描
    public static void quickSort(int a[],int s,int e){
        int i = s;int j = e;int temp;
        if(s<e){  //区间内至少存在两个记录的情况
            temp = a[s];  //用区间内第一个记录为基准
         while(i!=j){          //从区间两端交替向中间扫描，直至i=j为止
             while(j>i && temp<a[j]) 
                 j--;           //从右向左扫描，找到第一个小于 temp的a[j]
             a[i] = a[j];
             while(i<j && temp >a[i])
                 i++;             //从左到右，找第一个大于temp的a[i]
             a[j] = a[i];
         }
         a[i] = temp;
         quickSort(a, s, i-1);  对左区间递归排序
         quickSort(a, i+1, e);  对右区间递归排序
        }
    }

}

快速排序是不稳定的排序算法，最坏的时间复杂度是O（n2）,
最好的时间复杂度是(nlogn),空间复杂度为O(logn)。