排序算法(Java)

冒泡排序

    public int[] bubble(int[] ary) {
        for (int i = 0; i < ary.length; i++) {
            // 每次确保ary[i]是最小的
            for (int j = i + 1; j < ary.length; j++) {
                if (ary[i] > ary[j]) {
                    int temp = ary[j];
                    ary[j] = ary[i];
                    ary[i] = temp;
                }
            }
        }
        return ary;
    }

插入排序

    public static int[] insert(int[] ary) {
        for (int i = 1; i < ary.length; i++) {
            // key就是一个临界点（哨兵）,前面是已经排好序的，后面是未排序的
            int key = ary[i], j;
            // 用key和他前面的值依次比较，发现比该值大就让其后移一位
            for (j = i - 1; j >= 0 && ary[j] > key; j--) {
                ary[j + 1] = ary[j];
            }
            // 走到这里说明key>ary[j],因为之前j是已经-1啦，所以在此+1
            ary[j + 1] = key;
        }
        return ary;
    }

快速排序

package common.algorithm.sort;
import java.util.Arrays;
/**
 * 该方法的基本思想是：<br/>
 * 1.先从数列中取出一个数作为基准数。<br/>
 * 2.分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。<br/>
 * 3.再对左右区间重复第二步，直到各区间只有一个数。<br/>
 * 复杂度O(N*logN)
 * @author vv
 * @since 2017/9/4.
 */
public class QuickSort {

    /**
     * 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小
     * 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
     * @param ary
     */
    public int[] sort(int[] ary) {
        quickSort(ary, 0, ary.length - 1);
        return ary;
    }

    private void quickSort(int[] ary, int low, int high) {
        if (low < high) {
            // 将ary数组进行一分为二
            int middle = partition(ary, low, high);
            // 对低字表进行递归排序
            quickSort(ary, low, middle - 1);
            // 对高字表进行递归排序
            quickSort(ary, middle + 1, high);
        }
    }

    /**
     * 以list的第一个为中轴pivot = ary[low];比pivot小的放在左边，比其大的放在右边，最后返回pivot
     * 
     * @param ary
     * @param low ary的最低位
     * @param high ary的最高位
     * @return
     */
    private int partition(int[] ary, int low, int high) {
        // 数组的第一个作为中轴,低位的值给了pivot，所以ary[low]空出来了
        int pivot = ary[low];
        while (low < high) {
            // 高位比中轴大，则高位索引-1
            while (low < high && ary[high] >= pivot) {
                high--;
            }
            // 高位的值比中轴小，则放到ary[low]上，此后ary[high]又空出来了
            ary[low] = ary[high];

            // 低位比中轴小，则低位索引+1
            while (low < high && ary[low] <= pivot) {
                low++;
            }
            // 比中轴大的记录移到高端
            ary[high] = ary[low];
        }
        // 此处low==high
        ary[low] = pivot;
        // 返回中轴的位置
        return low;
    }

    public static void main(String[] args) {
        QuickSort sorter = new QuickSort();
        System.out.println(Arrays.toString(sorter.sort(new int[] { 2, 5, 2, 1, 7, 3 })));
    }
}

归并排序

package common.algorithm.sort;
import java.util.Arrays;
/**
 * 归并排序是分治法（Divide and Conquer）的一个非常典型的应用<br/>
 * 将已有序的子序列合并，得到完全有序的序列<br/>
 * 两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]<br/>
 * 每次从两个段中取出第一个(最小的)比较，将较小者放入temp中。最后将各段中余下的部分直接复制到temp中。
 *
 * <pre>
 *     {5, 4, 3, 2, 2, 4, 1}
 *     {4,5} {2,3}  {2,2} {4,1}
 *     {2,3,4,5} {1,2,2,4}
 *     {1,2,2,2,3,4,4,5}
 * </pre>
 * 
 * @author vv
 * @since 2016/9/20.
 */
public class MergeSort {

    /**
     * 对数组的begin到end 进行排序
     *
     * @param array 需要排序的数组
     * @param begin 起始位置
     * @param end 终止位置
     */
    public void sort(int[] array, int begin, int end) {
        // 分到最后，i==j说明该组中只有一个元素了
        if (begin < end) {
            int middle = (begin + end) / 2;
            // 递归处理相关的合并事项
            sort(array, begin, middle);// 对第一组排序
            sort(array, middle + 1, end);// 对第二组排序
            merge(array, begin, middle, end);// 合并两组
        }
    }

    /**
     * 对这两组进行合并，从每组中选择最小值进行对比，小的放到temp中
     *
     * @param array 需要排序的原始数组
     * @param low low--middle 为第一组
     * @param middle 分界点
     * @param high middle+1--high 为第二组
     */
    private void merge(int[] array, int low, int middle, int high) {
        int i = low; // i是第一段序列的下标
        int j = middle + 1; // j是第二段序列的下标
        int k = 0; // k是临时存放合并序列的下标
        int[] temp = new int[high - low + 1]; // array2是临时合并序列

        while (i <= middle && j <= high) {
            // 判断第一段和第二段取出的数哪个更小，将其存入合并序列temp，并继续向下扫描
            if (array[i] <= array[j]) {
                temp[k] = array[i];
                i++;
            } else {
                temp[k] = array[j];
                j++;
            }
            k++;
        }

        // 若第一段序列还没扫描完，将其全部复制到合并序列
        while (i <= middle) {
            temp[k] = array[i];
            i++;
            k++;
        }

        // 若第二段序列还没扫描完，将其全部复制到合并序列
        while (j <= high) {
            temp[k] = array[j];
            j++;
            k++;
        }

        // 将合并序列复制到原始序列中
        for (k = 0, i = low; i <= high; i++, k++) {
            array[i] = temp[k];
        }
    }

    public static void main(String[] args) {
        int[] ary = { 5, 4, 3, 2, 2, 4, 1 };
        MergeSort sort = new MergeSort();
        sort.sort(ary, 0, ary.length - 1);
        System.out.println(Arrays.toString(ary));
    }
}

堆排序

package common.algorithm.sort;

import java.util.Arrays;

/**
 * 归并排序是分治法（Divide and Conquer）的一个非常典型的应用<br/>
 * 将已有序的子序列合并，得到完全有序的序列<br/>
 * 两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]<br/>
 * 每次从两个段中取出第一个(最小的)比较，将较小者放入temp中。最后将各段中余下的部分直接复制到temp中。
 *
 * <pre>
 *     {5, 4, 3, 2, 2, 4, 1}
 *     {4,5} {2,3}  {2,2} {4,1}
 *     {2,3,4,5} {1,2,2,4}
 *     {1,2,2,2,3,4,4,5}
 * </pre>
 * 
 * @author vv
 * @since 2016/9/20.
 */
public class MergeSort {

    /**
     * 对数组的begin到end 进行排序
     *
     * @param array 需要排序的数组
     * @param begin 起始位置
     * @param end 终止位置
     */
    public void sort(int[] array, int begin, int end) {
        // 分到最后，i==j说明该组中只有一个元素了
        if (begin < end) {
            int middle = (begin + end) / 2;
            // 递归处理相关的合并事项
            sort(array, begin, middle);// 对第一组排序
            sort(array, middle + 1, end);// 对第二组排序
            merge(array, begin, middle, end);// 合并两组
        }
    }

    /**
     * 对这两组进行合并，从每组中选择最小值进行对比，小的放到temp中
     *
     * @param array 需要排序的原始数组
     * @param low low--middle 为第一组
     * @param middle 分界点
     * @param high middle+1--high 为第二组
     */
    private void merge(int[] array, int low, int middle, int high) {
        int i = low; // i是第一段序列的下标
        int j = middle + 1; // j是第二段序列的下标
        int k = 0; // k是临时存放合并序列的下标
        int[] temp = new int[high - low + 1]; // array2是临时合并序列

        while (i <= middle && j <= high) {
            // 判断第一段和第二段取出的数哪个更小，将其存入合并序列temp，并继续向下扫描
            if (array[i] <= array[j]) {
                temp[k] = array[i];
                i++;
            } else {
                temp[k] = array[j];
                j++;
            }
            k++;
        }

        // 若第一段序列还没扫描完，将其全部复制到合并序列
        while (i <= middle) {
            temp[k] = array[i];
            i++;
            k++;
        }

        // 若第二段序列还没扫描完，将其全部复制到合并序列
        while (j <= high) {
            temp[k] = array[j];
            j++;
            k++;
        }

        // 将合并序列复制到原始序列中
        for (k = 0, i = low; i <= high; i++, k++) {
            array[i] = temp[k];
        }
    }

    public static void main(String[] args) {
        int[] ary = { 5, 4, 3, 2, 2, 4, 1 };
        MergeSort sort = new MergeSort();
        sort.sort(ary, 0, ary.length - 1);
        System.out.println(Arrays.toString(ary));
    }
}