排序算法

以下内容转自http://www.cnblogs.com/liuyitian/p/4077624.html
 /**
     * 冒泡排序：每次只能确定一位最大的，放置数组末尾 ，下次忽略已经确定的最大值继续比较
     * 优点：稳定
     * 缺点：效率底下（重复相邻数据比较，且每次比较都会进行位置置换）
     * @param arr
     * @return
     */
    public static int[] bubbleSort(int[] arr) {
        int len = arr.length; // 数组长度
        for (int i = 0; i < len; i++) { // 遍历数组，用来限制内循环次数
            for (int j = 1; j < len - i; j++) { // 内循环，依次减少1个次数（即为比较几次，就忽略后几位）
                if (arr[j - 1] > arr[j]) { // 如果前一位大于后一位，即 前>后，需要交换位置
                    int k = arr[j - 1]; // 把前面的先缓存起来
                    arr[j - 1] = arr[j]; // 让前面的等于后一位
                    arr[j] = k; // 后一位等于前一位之前的缓存值
                }
            }
        }
        return arr;
    }

　　

/**
     * 插入排序，默认第一位已经排好序，从第二位开始依次向前比较,确定自己的位置后插入，即前一位小余或等于当前，且后一位大于当前。
     * 插入后，自己新位置后面的元素依次向后移位， 完成一轮插入排序
     * @param arr
     * @return
     */
    public static int[] insertSort(int[] arr) {
        int len = arr.length;
        for (int i = 1; i < len; i++) {
            if (arr[i - 1] > arr[i]) {
                int k = arr[i];
                int j = i;
                while (j > 0 && arr[j - 1] > k) {
                    arr[j] = arr[j - 1];
                    j--;
                }
                arr[j] = k;
            }
        }
        return arr;
    }

/**
     * 选择排序，从当前位（0开始）开始和下一位依次比较，找到最小元素,让当前位和最小元素换位，其他元素不变
     * 继续从当前位的下一位开始，依次查找最小元素并换位，直至最后一位
     * @param arr
     * @return
     */
    public static int[] selectSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            int min = arr[i]; // 每次都认为当前队列第一位为最小值，进行缓存
            int index = i;       // 缓存最小值（变化）坐标
            for (int k = i + 1; k < len; k++) { // 向后比较
                if (arr[k] <= min) { // 如果后一个小于等于前一个
                    min = arr[k]; // 更换最小值
                    index = k; // 变更最小值坐标
                }
            }
            if (min == arr[i]) // 相等则不变化，默认保留当前队列第一个为最小
                continue;
            // 循环完毕，找出了最小值的坐标，即为index，把当前坐标i元素和最小元素换位
            int k = arr[i];
            arr[i] = arr[index];
            arr[index] = k;
        }
        return arr;
    }

　　

/**
     * 快速排序，返回一个中轴下标
     * @param arr
     * @param low    队列起始下标
     * @param high    队列结束下标
     * @return
     */
    public int quickSort(int[] arr, int low, int high) {
        int tmp = arr[low]; // 数组的第一个作为中轴
        
        while (low < high) {
            while (low < high && arr[high] >= tmp) {
                high--;
            }
            arr[low] = arr[high]; // 比中轴小的记录移到低端
            
            while (low < high && arr[low] <= tmp) {
                low++;
            }
            arr[high] = arr[low]; // 比中轴大的记录移到高端
        }

        arr[low] = tmp; // 中轴记录到尾
        return low; // 返回中轴的位置
    }
    
    /** 递归调用快速排序方法，对数组进行排序 **/
    public void _quickSort(int[] list, int low, int high) {
        if (low < high) {
            int middle = quickSort(list, low, high); // 获得中轴下标
            // 对前部分进行排序，递归进行，此时不会执行后半部分，直至不能再次拆分，再依次执行下半部分
            _quickSort(list, low, middle - 1);
            // 对下半部分进行排序
            _quickSort(list, middle + 1, high); 
        }
    }