选择排序算法原理及实现（Java/Python）

选择排序算法思路

• 对输入的N个元素进行遍历，找到N个元素中的最小值/最大值
• 将最小值/最大值与N个元素的首个元素互换
• 对剩下的N-1个元素进行选择排序

算法实现
迭代（python）

def exchange(lst, a, b):
    """ 根据给定的索引，交换list中的元素 """
    lst[a], lst[b] = lst[b], lst[a]
    return lst

def find_min_idx(x, a):
    """ 找到当前list中最小值的索引"""
    cur_min = a
    for i in range(a, len(x)):
        if x[i] < x[cur_min]:
            cur_min = i
    return cur_min

def selectsort_iter(lst):
    """ 使用迭代进行选择排序 """
    for i in range(len(lst)-1):
        min_idx = find_min_idx(lst, i)
        lst = exchange(lst, min_idx, i)
    return

递归（python）

def exchange(lst, a, b):
    """ 根据给定的索引，交换list中的元素 """
    lst[a], lst[b] = lst[b], lst[a]
    return lst

def find_min_idx(x, a):
    """ 找到当前list中最小值的索引"""
    cur_min = a
    for i in range(a, len(x)):
        if x[i] < x[cur_min]:
            cur_min = i
    return cur_min

def selectsort_recur(lst, start=0):
    """ 使用递归进行选择排序 """
    if start >= len(lst) - 1:
        return
    else:
        min_idx = find_min_idx(lst, start)
        exchange(lst, min_idx, start)
        selectsort_iter(lst, start+1)
        return

迭代（java）

class SelecSort_iter {
    /** 根据给定的索引交换数组中的元素 */
    public static void exchange(int[] x, int a, int b) {
        int temp = x[a];
        x[a] = x[b];
        x[b] = temp;
    }

    /** 返回给定数组中最小值的索引 */
    public static int findMinIdx(int[] x, int a) {
        int cur_min = a;
        for (int i = a; i < x.length; i++) {
            if (x[i] < x[cur_min]) {
                cur_min = i;
            }
        }
        return cur_min;
    }

    /** 使用迭代进行选择排序 */
    public static void sortIter(int[] nums) {
        int min_idx = 0;
        for (int i = 0; i < nums.length; i++) {
            min_idx = findMinIdx(nums, i);
            exchange(nums, i, min_idx);
        }
    }
}

递归（java）

class SelecSort_recur {
    /** 根据给定的索引交换数组中的元素 */
    public static void exchange(int[] x, int a, int b) {
        int temp = x[a];
        x[a] = x[b];
        x[b] = temp;
    }

    /** 返回给定数组中最小值的索引 */
    public static int findMinIdx(int[] x, int a) {
        int cur_min = a;
        for (int i = a; i < x.length; i++) {
            if (x[i] < x[cur_min]) {
                cur_min = i;
            }
        }
        return cur_min;
    }

    /** 使用递归进行选择排序 */
    public static void sortRecur(int[] nums, int start) {
        if (start >= nums.length - 1) {
            return ;
        } else {
            int min_idx = findMinIdx(nums, start);
            exchange(nums, min_idx, start);
            sortRecur(nums, start+1);
            return ;
        }
    }
}

时间复杂度
O(N^2)