002选择排序python实现

选择排序原理如下：（我们拿升序进行举例）
原序列array = [5、4、3、2、1]，经过选择排序算法后，得到的数列：[1、2、3、4、5]
详细步骤如下：
第一轮：假设原序列中第一个数字就是最小的，此时声明一个变量record，用来记录最小元素的下标，此时record中的值为0。
第一次：array[record]与第二个元素进行比较，注意：此时array[record]为第一个元素，既本次相当于第一个元素与第二个元素进行比较
       情况有如下三种：
       第一种：array[record]大于第二个元素
       第二种：array[record]等于第二个元素
       第三种：array[record]小于第二个元素

       进行比较运算：
       如果array[record]大于第二个元素，那么array[record]就不是前两个元素中最小的，前两个元素中最小的是第二个元素，
       此时更新记录，记录第二个元素的下标，既此时record=1。
       如果array[record]等于第二个元素，那么我们可以认为array[record]就是两个元素中最小的，此时无需更新记录，
       如果array[record]小于第二个元素，那么array[record]就是两个元素中最小的，此时无需更新记录。

       当第一次比较运算结束后，record中记录的下标为两个元素中最小的那个元素的下标了，此时array[record]就是前两个元素
       中的最小的元素了。

       就本案例来说，此时record=1, array[record] = 4

第二次：array[record]与第三个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是三个元素中最小的元素的下标了。
        就本案例来说，此时record=2, array[record] = 3

第三次：array[record]与第四个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是四个元素中最小的元素的下标了。
        就本案例来说，此时record=3, array[record] = 2

第四次：array[record]与第五个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是五个元素中最小的元素的下标了。
        就本案例来说，此时record=4, array[record] = 1

此时第一轮排序结束，
        就本案例来说，此时序列情况为5、4、3、2、1，record中的记录为4
        此时，array[record]为整个数组中最小的元素，他应该出现在0号位置，
        所以将array[record]与序列第一个位置的元素进行交换，
        此时，最小的元素在0号位置，而原来0号位置的元素在4号位置上（也就是最后一个位置上）
        就本案例来说，此时序列情况为1、4、3、2、5，record中的记录为4
        此时，最小的元素就到了第一个位置上了，但是后面四个元素还未进行排序，仍然需要进行排序操作。

第二轮：此时注意，经过第一个轮后，第一个元素已经是整个序列中最小的元素了，此时需要从第二个开始，比较以后的元素
假设第二个元素为最小的元素，则此时令record=1，

第一次：array[record]（本数组的第二个元素）与第三个元素进行比较，重复比较运算步骤，当运算结束时，
        record记录的就是这两个元素中最小的元素的下标了。
        就本案例来说，此时record=2, array[record] = 3

第二次：array[record]与第四个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是这三个元素中最小的元素的下标了。
        就本案例来说，此时record=3, array[record] = 2

第三次：array[record]与第五个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是这四个元素中最小的元素的下标了。
        就本案例来说，此时record=3, array[record] = 2。

第二轮排序结束，就本案例来说，此时序列情况为1,4,3,2,5, record=3
        此时，array[record]应该出现在1号位置上，
        所以，array[record]与array[1]进行交换，
        此时，array[1]就是剩下四个元素中最小的元素了。原数组中的1号位置的元素在4号位置上。
        此时，序列情况为[1,2,3,4,5]

第三轮开始：
    注意：虽然目前数组已经是有序的了，但是这是因为我们选取数组比较特殊，要知道此时后三个元素仍是没有进行排序的，仍然
    需要排序来进行进一步检测。

    此时前两个元素已经排序完毕，则从第三个元素开始往后排序，此时假设最小的元素为第三个元素，此时record=2，

    第一次：array[record]与第四个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是这两个元素中最小的元素的下标了。
        就本案例来说，此时record=2, array[record] = 3

    第二次：array[record]与第五个元素进行比较，复比较运算步骤，当运算结束时，record记录的就是这三个元素中最小的元素的下标了。
        就本案例来说，此时record=2, array[record] = 3

第三轮结束
    此时，需要把array[record]放到2号位置上，
    交换array[record]与array[2]
    此时，前三个元素排序完毕，还差后两个，此时序列情况为[1,2,3,4,5]

第四轮开始：此时注意，经过前三轮后，前三个元素就以排好序，此时从第四个开始往后比较，假设第四个元素为最小的元素，
则此时record=3，

    第一次：array[record]与第五个元素进行比较，重复比较运算步骤，当运算结束时，record记录的就是这两个元素中最小的元素的下标了。
        就本案例来说，此时record=3, array[record] = 4

第四轮结束
    交换array[record]与array[4]中的内容。

至此，整个排序结束。

通过观察我们发现，从第三轮开始，array[record]就在我们最初假设的位置上，所以是无需在将其放到正确的位置上的，
所以在每次将最小元素放入正确位置时，可以先进行判断，如果需要交换再交换否则无需交换。

总结：
当有五个元素的时候，我们共进行了4轮比较，如果是n个元素，则会进行n-1轮比较。
就本案例来说
第一轮：四次
第二轮：三次
第三轮：二次
第四轮：一次
所以，每轮比较的次数为参加比较元素的个数减一次，这是因为每次都要选出一个与其余的进行比较。
即如果有n个元素参与比较，则需要比较n-1次

所以整个选择排序需要进行比较的总次数为n(n-1)/2

选择排序的原理为：
每一轮都把一元素放到正确的位置上，可以从第一个位置开始放，也可以从最后一个位置开始放。
每一轮都会假设一个最小的元素，然后用其跟其余的元素进行比较验证，找出真正最小的元素下标，
然后将其放入数组中对应的位置上。
对比冒泡排序，其节省在交换两个数的运算上，因为经过一轮检测，如果record与需要交换的位置是一样的则无需进行交换。

# 升序排序
def sort_select01(array): # 从第一个位置开始放，
    length = len(array); # 获取数组的长度

    for i in range(length-1): # 共 n-1 轮
        record = i;

        for j in range(i+1, length): # 共参与比较的元素个数-1次
            if array[record] > array[j]:
                record = j;

        if record != i: # 当record和假设不一致时才交换
            array[record], array[i] = array[i], array[record];

    return array;

# 升序排序，从最后一个元素开始放，所以需要从后往前比
def sort_select02(array):
    length = len(array);

    i = length - 1;
    while i > 0:
        record = i; # 注意，由于是从后放，且是升序，所以最后一个元素应该是最大的，每次都要找出最大的元素

        j = i - 1;
        while j >= 0:
            if array[record] < array[j]:
                record = j;
            j -= 1;

        if record != i:
            array[record], array[i] = array[i], array[record];

        i -= 1;

    return array;