几个算法

1.冒泡排序

 public void sort(int[] array) {
        for (int i = array.length -1; i > 0; --i) {
            for (int j = 0; j < i; ++j) {
                if (array[j + 1] < array[j]) {
                    SortUtil.swap(array, j + 1, j);
                }
            }
        }
    }

2.选择排序

  public void sort(int[] array) {
        int minIndex = 0;
        for (int i = 0; i < array.length; i++) {
            minIndex = i;
            
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                SortUtil.swap(array, i, minIndex);
            }
        }

3.快速排序

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

4.插入排序

  public void sort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i; j > 0; j--) {
                if (array[j] < array[j - 1]) {
                    SortUtil.swap(array, j, j - 1);
                }
            }
        }
    }