Java数组的排序算法

　　在Java中，实现数组的排序算法有很多，如冒泡排序法、选择排序法、直接插入法和快速排序法、归并排序等。下面介绍几种排序算法的具体 实现。

　　本文引用文献：Java必须知道的300个问题。

1.冒泡排序法

　　1.1 基本思想：

　　　　比较待排序的数据元素中的相邻元素：如果前面的元素大于后面的元素，那么将两个元素交换位置；否则不变。即：永远保持大的元素值在待排序元素中的最后面位置。这样，数组元素就像气泡一样从底部上升到顶部。

　　1.2 过程实例：

　　　　每一轮，排序数组的长度减1次（每一轮结束后，最大元素都是最后一个元素。因此下轮比较过程中最后一次比较不用进行。）

　　1.3 代码实现

public static void main(String[] args) {
    //初始化数组
    int[] array = {63,4,24,1,3,13};
    //排序
    for (int i = 1; i < array.length; i++) {
        for (int j = 0; j < array.length - i; j++) {
            if(array[j] > array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;  
            }
        }
    }
    //输出结果
    System.out.println(Arrays.toString(array));
}

 

2. 选择排序法

　　2.1 基本思想

　　　　每一轮从待排序的数据元素中选出最小（最大）的一个元素，将该元素与待排序的数据元素中的第一位（最后一位）互换位置，直到全部待排序的数据元素排完。　　

　　2.2 过程实例　　

  　2.3 代码实现

//初始化数组
int[] array = {63,4,24,1,3,13};

//排序
int len = array.length;
//控制轮数
for (int i = 1; i < len; i++) {
    int max = array[0];
    int index = 0;
    //查找最大值
    for (int j = 1; j < len - (i - 1); j++) {
        if(max < array[j]){
            max = array[j]; 
            index = j;
        }
    }
    //互换位置
    int temp = array[index];
    array[index] = array[len - i];
    array[len - i] = temp;
}

//输出
System.out.println(Arrays.toString(array));

 

3. 直接插入排序法

　　3.1 基本思想

　　　　1. 将n个有序元素放在数组中 --> 2.确认要插入元素的位置 --> 3.将数组中的要插入元素的位置后面的元素向后移一个位置  --> 4.将要出如的元素插到合适的位置上 --> 5.重复2. 3. 4.直到所有元素均插入到数组中。

　　3.2 过程实例

　　　　

 

　　3.3 代码实现

//初始化数组
int[] array = {60,40,90,30,80,70,50};

//排序
int j;
for (int i = 1; i < array.length; i++) {
    int temp = array[i];
    for (j = i - 1; j >= 0 && array[j] > temp; j--) {
        array[j+1] = array[j];
    }
    array[j+1] = temp;
}
//输出
System.out.println(Arrays.toString(array));

 

4. 快速排序法

 　　4.1 基本思想

　　　　通过一趟排序将要排序的数据分割成独立的两部分（通常选取中数作为分割线），其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据进行快速排序，整个过程可以通过递归进行。

　　4.2 过程实例

 

　　4.3 代码实现

public static void main(String[] args) {
    //初始化数组
    int[] array = {49,38,65,97,76,13,27,49};
        
    //排序
    quickSort(array, 0, array.length - 1);
        
    //输出
    System.out.println(Arrays.toString(array));
        
}

private static void quickSort(int[] array, int lowIndex, int highIndex) {
    int lo = lowIndex;
    int hi = highIndex;
    int mid;
    if(highIndex > lowIndex){
        mid = array[(lowIndex + highIndex) / 2];
        while(lo <= hi){
            while((lo < highIndex) && (array[lo] < mid)){
                ++lo;
            }
            while(hi > lowIndex && array[hi] >mid){
                --hi;
            }
            if(lo <= hi){
                swap(array,lo,hi);
                ++lo;
                --hi;
            }
        }
        if(lowIndex <hi){
            quickSort(array, lowIndex, hi);
        }
        if(lo < highIndex){
            quickSort(array, lo, highIndex);
        }
    }
}

private static void swap(int[] array, int lo, int hi) {
    int temp = array[lo];
    array[lo] = array[hi];
    array[hi] = temp;
}

　　4.4 算法评价

　　　　快速排序是通用排序算法的传统选择。 

 

5. 归并排序

　　5.1 基本思想

　　　　将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

　　5.2 过程实例

　　　　将序列拆分成子序列（每个子序列中有两个元素），将每个子序列进行排序（如：第一轮）；然后将拆分后的子序列进行两两合并，如果有落单的子序列，合并入上一组（如：第二轮）。重复合并的逻辑，一直到最后只剩下一个数组（该数组以实现排序），结束。

 

 　　5.3 代码实现

/**
 * 归并排序：
 *  1.将数组进行折半拆分，一直拆分到不能再拆分
 *  2.对拆分后的子数组进行比较合并
 *
 *
 * 时间复杂度：O(NlogN)
 *
 * 空间复杂度：O(n)
 *   归并排序算法排序过程中需要额外的一个序列去存储排序后的结果，所占空间是n，因此空间复杂度为O(n)
 */
public class Merge {


    public static void main(String[] args) {
        int[] elements = new int[]{4,9,34,2,76,33,91,43,22};
        sort(elements, 0, elements.length-1);
        //System.out.println(Arrays.toString(elements));
    }

    public static void sort(int[] elements, int start, int end) {
        if(start >= end) return;
        //折半拆分
        int mid = (start + end) >> 1;
        sort(elements, start, mid);
        sort(elements, mid+1, end);
        //排序合并
        merge(elements,start,mid,end);

    }

    /**
     * 二路归并
     *    原理：将两个有序表合并和一个有序表
     * @param elements  待排序的数组
     * @param start 需要合并的左边数组的起始下标
     * @param mid  需要合并的左边数组的结束下标
     * @param mid +1 需要合并的右边数组的起始下标
     * @param end  需要合并的右边数组的结束下标
     */
    public static void merge(int[] elements, int start, int mid, int end) {
        //合并后的数组：存储比较后的元素
        int[] result = new int[end-start+1];
        //合并数组的下标
        int index = 0;
        //左边数组的指针
        int p1 = start;
        //右边数组的指针
        int p2 = mid+1;
        //对比合并
        while(p1 <= mid && p2 <= end) {
            if (elements[p1] <= elements[p2]) {
                result[index++] = elements[p1++];
            } else {
                result[index++] = elements[p2++];
            }
        }
        //存储左边数组未保存的数据
        while (p1 <= mid) {
            result[index++] = elements[p1++];
        }
        //存储右边数组未保存的数据
        while (p2 <= end) {
            result[index++] = elements[p2++];
        }
        //将合并后的数据放回原数组
        for (int value : result) {
            elements[start++] = value;
        }
    }
}

 

　　5.4 算法评价

　　　　归并排序的一个主要的优点是：稳定，即不需要交换相同的元素。

　　　　因此多应用于以下场景：假设有一张按照姓名排序的员工列表。现在要按工资排序。使用归并排序可以在按照工资排序的时候保留按名字排列的顺序（即：排序的结果是，先按工资排序，工资相同的按照姓名排序。）

 

　　更多内容，请访问：http://www.cnblogs.com/BlueStarWei/