排序算法——简单选择排序(Python&Java)

基本思想

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

算法

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1个记录中再选出关键码最小的记录与第二个记录交换；

以此类推…..

第i 趟，则从第i 个记录开始的n-i+1个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

Code

JAVA:

import java.util.Arrays;

public class selectionSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[] = {3,1,5,7,2,4,9,6};
        SelectionSort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void SelectionSort(int[] arr) {
        int n = arr.length;
        for (int i=0;i<n;i++) {
            int tmp = 0;
            int index = i;
            //找到最小值
            for (int j=i+1;j<n;j++) {
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }
            //交换
            tmp = arr[index];
            arr[index] = arr[i];
            arr[i] = tmp;
        }
    }
}

Python

a = [3,1,5,7,2,4,9,6]

def Selection_Sort(arr):
    n = len(arr)
    for i in range(n):
        tmp = i
        for j in range(i+1,n):
            if arr[tmp] > arr[j]:
                arr[j],arr[tmp] = arr[tmp],arr[j]
    return arr

print(Selection_Sort(a))

简单选择排序的改进——二元选择排序

简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。

JAVA

    public static void SelectionTwoSort(int[] arr) {
        int n = arr.length;
        for (int i=0;i<=n/2;i++) {
            int tmp = 0;
            int tmp_max = n-i-1;
            int tmp_min = i;
            for (int j = i+1; j<n-i;j++) {
                if (arr[j] > arr[tmp_max]) {
                    tmp_max = j;
                }
                else if (arr[j] < arr[tmp_min]) {
                    tmp_min = j;
                }
            }
            tmp = arr[i];
            arr[i] = arr[tmp_min];
            arr[tmp_min] = tmp;
            tmp = arr[n-i-1];
            arr[n-i-1] = arr[tmp_max];
            arr[tmp_max] = tmp;
        }

    }

Python

a = [3,1,5,7,2,4,9,6]
def Selection_Two_Sort(arr):
    n = len(arr)
    for i in range(int(n/2)+1):
        tmp_max = n-i-1
        tmp_min = i
        for j in range(i+1,n-i):
            if arr[tmp_max] < arr[j]:
                arr[j],arr[tmp_max] = arr[tmp_max],arr[j]
                continue
            elif arr[tmp_min] > arr[j]:
                arr[j],arr[tmp_min] = arr[tmp_min],arr[j]

    return arr

print(Selection_Two_Sort(a))

时效

时间复杂度O(n^2)

在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。因此选择排序算法是一个不稳定的算法。

参考

http://blog.csdn.net/hguisu/article/details/7776068/

http://www.cnblogs.com/jingmoxukong/p/4303289.html