初級排序算法

本質是對要排序的數組進行嵌套循環，內層循環負責局部的排序，外層循環負責剩余的無序元素的遞減。所以你只要理解嵌套循環和比較大小就能很快的掌握初級排序算法。

選擇排序

一個無序的數組 a = [0, 4, 6, 3, 8, 2, 3, 9], 你也可以把a的元素想象成任何現實中可比較的具體物體。例如，有10根長短不一的木條，我們如何對它們進行排序？一個最直接的思想，先拿出最短的放到最前面，在剩余的木條中再拿出最短的放在第二位...直到最後一根木條。從中我們可以看出，1. 我們需要再一次循環比較中找出一個最小的值（局部排序，每次找到的元素都是最小的和之前的元素組合起來就是有序的）。2，剔除掉這個最小的值，在剩余的值中重復第一步（無序的元素在遞減，知道為0）。寫成偽代碼如下：

對數組a = [0, 4, 6, 3, 8, 2, 3, 9]進行選擇排序

//對無序的元素進行循環遞減。

for ( i = 0; i < a.length; i++) //外層循環負責遞減無序的元素

minIndex = i; //在此處我們需要先假設最小的元素在i位置上，至於真正的最小元素在哪裏，有內循環負責找到

for ( j = i +1 ; j < a.length; j ++) //負責找到無序元素中的最小元素索引

　　 if ( a[minIndex] > a[j])

　　　　minIndex = j

exchang(a, i, minIndex) //exchang函數負責將數組中i, minIndex位置的元素進行交換。此時通過內循環我們找到了最小的元素，在外循環中我們將其放在了外循環的最前的位置，外循環遍歷的無序元素個數減一。如此，當外循環走完，數組也就排序完成了。具體代碼如下：

javascript版:

//封裝常用的比較，交換函數
const utils = {
    less: function(a, b){
        return a < b;
    },
    exchange: function(arr, i, j){
        if(i === j) return;
        let tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
};

//具體每一步的含義參考偽代碼。
function sortArr(arr){
    let length 
 
= arr.length;
    for(let i = 0; i < length; i++){
        let minIndex = i;
        for(let j = i + 1; j < length; j++){
            if(utils.less(arr[j], arr[minIndex])){
                minIndex = j;
            }
        }
        utils.exchange(arr, i, minIndex);
    }
}

//生成隨機無序的數組
function genArr(length){
    let arr = [];
    for(let i = 0; i < length; i++){
        arr.push(Math.floor(Math.random() * 1000));
    }
    return arr;
}

//測試排序函數
let arr = genArr(20);
console.log(`排序前的arr: ${arr}`);
sortArr(arr);
console.log(`排序後的arr: ${arr}`);

測試結果：

排序前的arr: 677,967,80,43,46,457,221,961,675,539,937,429,911,466,263,205,936,790,239,936
排序後的arr: 43,46,80,205,221,239,263,429,457,466,539,675,677,790,911,936,936,937,961,967

java版

import java.util.Arrays;

public class SelectSort{
    SelectSort(){
    }

    //封裝常用的比較，交換, 創建無序數組的方法。
    public static final class SortUtils{
        public static boolean less(int a, int b){
            return a < b;
        }
        public static void exchange(int[] arr, int i, int j){
            if( i == j) return;
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
        public static int[] genArr(int length){
            int[] arr = new int[length];
            for(int i = 0; i < length; i++){
                arr[i] = (int)Math.floor(Math.random() * 1000);
            }
            return arr;
        }
    }
    public static void main(String[] args) {
        //創建無序數組
        int[] arr = SortUtils.genArr(10);
        System.out.println("排序前的arr: " +  Arrays.toString(arr));
        //排序
        sort(arr);
        System.out.println("排序後的arr: " +  Arrays.toString(arr));
    }

    public static void sort(int[] arr){
        int length = arr.length;
        for(int i = 0; i < length; i++){
            int minIndex = i;
            for(int j = i + 1; j < length; j++){
                if(SortUtils.less(arr[j], arr[minIndex])){
                    minIndex = j;
                }
            }
            SortUtils.exchange(arr, i, minIndex);
        }
    }
}

運行結果

排序前的arr: [416, 993, 557, 593, 208, 307, 533, 393, 607, 301]
排序後的arr: [208, 301, 307, 393, 416, 533, 557, 593, 607, 993]

Python版

import random
class Utils(object):
    def __ini__(self):
        pass
    @staticmethod
    def less(a, b):
        if(a > b):
            return False
        else:
            return True

    @staticmethod
    def exchange(arr, i, j):
        tmp = arr[i]
        arr[i] = arr[j]
        arr[j] = tmp

    @staticmethod
    def gen_arr(length):
        arr = []
        for i in range(length):
            arr.append(random.randint(0, 999))
        return arr

def sort(arr):
    length = len(arr)
    for i in range(length):
        min_index = i
        for j in range(i+1, length):
            if(Utils.less(arr[j], arr[min_index])):
                min_index = j

        Utils.exchange(arr, i, min_index)

if(__name__ == ‘__main__‘):
    #創建隨機無序數組
    arr = Utils.gen_arr(10)
    print(‘排序前的arr: ‘, arr)
    sort(arr)
    print(‘排序後的arr: ‘, arr)

運行結果：

排序前的arr:  [139, 698, 787, 278, 434, 344, 265, 296, 878, 966]
排序後的arr:  [139, 265, 278, 296, 344, 434, 698, 787, 878, 966]

初級排序算法之選擇排序