java实现三种经典排序法

    这是我注册csdn后的第一次发博，在这里要感谢各位无私地博主们热心细致的奉献出自己的经验和代码。很久以来csdn上的博文对我的学习工作帮助
很大。所以我也将开发中的一些东西贴出来，希望帮助有类似问题的同行。
冒泡排序法：
每次将相邻的两个元素进行比较，将最小的靠前或将最大的靠后。
优点：稳定。
缺点：相对于其他算法，用时长，CPU占用高。
实例代码：

public class BubbleSort{
    public void sort(int[] a) {
        int temp = 0;
        for (int i = a.length - 1; i > 0; --i) {
            boolean isSort=false;
            for (int j = 0; j < i; ++j) {
                if (a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    isSort=true;
                }
            }
            if(!isSort)break;
        }
    }
}

快速排序法：
（快速排序是对冒泡排序的一种优化）原理是将一堆数据分成最大和最小两组数据，然后再对这两组分别进行冒泡排序。但他并不是一种稳定的排序算法。

public static void quickSort(int a[], int start, int end)
{        int i,j;
         i = start;
         j = end;
         if((a==null)||(a.length==0))
             return;
         while(i<j){
             while(i<j&&a[i]<=a[j]){     //以数组start下标的数据为key，右侧扫描
                 j--;
             }
             if(i<j){                   //右侧扫描，找出第一个比key小的，交换位置
                 int temp = a[i];
                 a[i] = a[j];
                 a[j] = temp;
             }
              while(i<j&&a[i]<a[j]){    //左侧扫描（此时a[j]中存储着key值）
                 i++;
               }
             if(i<j){                 //找出第一个比key大的，交换位置
                 int temp = a[i];
                 a[i] = a[j];
                 a[j] = temp;
             }
        }
        if(i-start>1){
             //递归调用，把key前面的完成排序
            quickSort(a,0,i-1);
        }
        if(end-j>1){
            quickSort(a,j+1,end);    //递归调用，把key后面的完成排序
        }
}

选择排序法：
每一次从一堆数据中取出最小的数放在前面。
优点：相对于其他算法，由于循环次数少，速度快，CPU占用低。
缺点：不稳定。
实例代码：

public class SelectionSort {
    public static void selectionSort(int[] values) {
        int temp = 0; // 数组元素交换时的临时变量
        // 进行数组排序
        for (int i = 0; i < values.length - 1; i++) {
            // 认为数组第i个元素是第i趟中的最小值，记录该索引。
            int minValueIndex = i;
            for (int j = i + 1; j < values.length; j++) {
                if (values[minValueIndex] > values[j]) {
                    minValueIndex = j; // 之前的假设不成立，重新记录数组中最小值的索引值。
                }
            }
            // 当minValueIndex值发生了变化才进行数组元素的交换
            if (minValueIndex != i) {
                temp = values[i];
                values[i] = values[minValueIndex];
                values[minValueIndex] = temp;
            }
        }
    }
    public static void main(String[] args) {
        // 初始化数组
        int[] values = {1, -1, 3, 3, 2, 9, -10, 7, 6, 5};
        // 调用方法
        selectionSort(values);
         
        // 打印数组
        for (int i = 0; i < values.length; i++) {
           System.out.println("values[" + i + "] = " + values[i]);
        }
    }
}