排序算法

排序算法

选择排序法（Selection Sort)

选择排序是一种简单直观的排序算法。本实例演示如何使用选择排序法对一维数组进行排序。

工作原理

选择排序的基本思想是，每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，知道全部带排序的数据元素排完。下面是一个数组排序过程的例子。

初始数组资源	【63 4 24 1 3 15】
第一趟排序后	【15 4 24 1 3 】 63
第二趟排序后	【15 4 3 1】 24 63
第三趟排序后	【1 4 3】 15 24 63
第四趟排序后	【1 3】 4 15 24 63
第五趟排序后	【1】 3 4 15 24 63

设计过程

生成随机数

int[] array = new int[10];              //
Random rand = new Random();             //创建随机数
for(int i = 0; i < array.length; i++){
    array[i] = rand.nextInt(50);
}

选择排序

int index = 0;
for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array.length - i; j++){
        if(array[j] > array[index]){        //查找最大值
            index = j;
        }
    }
    int temp = 0;
    temp = array[array.length - i];
    array[array.length - i] = array[index];
    array[index] = temp;
}

小结

选择排序法从数组中挑选最大值并放在数组最后，而遇到重复的相等值不会做任何处理，所以如果程序允许数组有重复值的情况，建议使用选择排序法，因为它的数据交换次数较少，相对速度也会略微提升，这取决于数组中重复值的数量。

冒泡排序法（BubbleSort）

基本思想

对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。
冒泡算法在双层循环中实现，其中外层循环控制排序轮数，要排序数组长度-1次。而内层循环主要是用于对比临近元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

实例编码

for(int i = 0; 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;
        }
    }
}

快速排序法（Quick Sort）

快速排序是对气泡排序的一种改进，其排序速度相对较快。

基本思想

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。
假设要排序的数组是A[1]…A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数据都放在它前面，所有比它大的数都放在它后面，这个过程称为一趟快速排序，递归调用此过程，即可实现数组的快速排序。

public void quickSort(int[] sortArray, int lowIndex, int highIndex){
    int lo = lowIndex;
    int hi = highIndex;
    int mid = (lowIndex + hightIndex) / 2;
    if(lowIndex < highIndex){
        while(lo < hightIndex && sortArray[lo] < sortAraay[mid]){
            ++lo;
        }
        while(hi > lowIndex && sortArray[hi] > sortArray[mid]){
            --hi;
        }
        if(lo < hi){
            swap(sortArray, lo, hi);
            ++lo;
            --hi;
        }
    }
    if(lowIndex < hi) {
        quickSort(sortArray, lowIndex, hi);
    }
    if(lo < highIndex){
        quickSort(sortArray, lo, highIndex);

public void swap(int[] swapArray, int i; int j){
    int temp = swapArray[i];
    swapArray[i] = swapArray[j];
    swapArray[j] = temp;
}

评价排序算法好坏的标准主要有两条，分别为：

• 指定时间和所需的辅助控件；
• 算法本身的复杂程度。

直接插入法（InsertSort）

基本思想

插入排序是将一个记录插入到有序数组中，使得到的新的数列仍然有序。插入排序算法的思想是，将n个有序数存放在数组a中，要插入的数为x，首先确定x插在数组中的位置p，数组中p之后的元素都向后移一个位置，空出a(p)，将x放入a(p)。这样即可实现插入后数列仍然有序。

实例编码

int temp;
int j;
for(int i = 1; i < array.length; i++){
    temp = array[i];
    for(j = i - 1; j >= 0 && array[j] > temp; j--){
        array[j + 1] = array[j];
    }
    array[j + 1] = temp;
}

排序算法的空间复杂度是指排序算法运行所需要的额外消耗存储空间，一般使用O()来表示，如直接插入排序的空间复杂度为O(1)。