初级排序算法

本质是对要排序的数组进行嵌套循环，内层循环负责局部的排序，外层循环负责剩余的无序元素的递减。所以你只要理解嵌套循环和比较大小就能很快的掌握初级排序算法。

选择排序

一个无序的数组 a = [0, 4, 6, 3, 8, 2, 3, 9], 你也可以把a的元素想象成任何现实中可比较的具体物体。例如，有10根长短不一的木条，我们如何对它们进行排序？一个最直接的思想，先拿出最短的放到最前面，在剩余的木条中再拿出最短的放在第二位...直到最后一根木条。从中我们可以看出，1. 我们需要再一次循环比较中找出一个最小的值（局部排序，每次找到的元素都是最小的和之前的元素组合起来就是有序的）。2，剔除掉这个最小的值，在剩余的值中重复第一步（无序的元素在递减，知道为0）。写成伪代码如下：

SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

对数组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]

 

 

 

扫码关注我们
微信号：SRE实战
拒绝背锅 运筹帷幄