算法一小时-选择排序

今天利用了一个小时的时间来复习了一下选择排序。

1. 程序模板

在开始之前，首先根据 Algorithms 书中的例子写了一个程序的模板。 书中的代码我稍作了修改。如下所示：

package com.jacob.demo;

/**
 * This is a sample for sort algorithms.
 * @author jacobqiao
 *
 */
public class Example {
    
    /**
     * The function for sort.
     * @param a
     */
    public static void sort(Comparable<String>[] a) {
        
    }
    
    /**
     * Compare if v is less than w.
     * @param v
     * @param w
     * @return
     */
    public static boolean less(Comparable<String> v, Comparable<String> w) {
        return v.compareTo((String) w) < 0;
    }
    
    /**
     * exchange two elements.
     * @param a
     * @param i
     * @param j
     */
    public static void exch(Comparable<String>[] a, int i, int j) {
        Comparable<String> t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    /**
     * Print array.
     * @param a
     */
    private static void show(Comparable<String>[] a) {
        for (int i= 0; i< a.length; i++) {
            System.out.println(a[i] + " ");
        }
        System.out.println();
    }
    
    /**
     * Judge if array is sorted
     * @param a
     * @return
     */
    public static boolean isSorted(Comparable<String>[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i-1])) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        String[] a = {};
        sort(a);
        assert isSorted(a);
        show(a);
    }
}

之后所有的排序基本上都会根据这个模板来修改。 该模板中主要包含几个方法：

sort() 用来写排序

less() 用来比较两个元素的大小

exch()用来交换数组中两个元素的位置

show()用来输出当前数组

2.选择排序的步骤

选择排序的步骤相对来说是比较简单的，主要有以下几步来完成：

（1）找到数组中最小的元素

（2）将最小的元素和数组的第一个元素交换位置

（3）在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。

  如此往复，一直到将数组余下的全部排序完。 

 

例如下面的一组字母：

S O R T E X A M P L E

 

开始排序:

 

A [O R T E X S M P L E]     找出最小的A，与第一位的S交换，然后将第一位指针后移

A E [R T O X S M P L E]     找出最小的E，与第一位的O交换，然后将第一位指针后移

A E E [T O X S M P L R]     找出最小的E，与第一位的R交换，然后将第一位指针后移

A E E L[ O X S M P T R]　  找出最小的L，与第一位的T交换，然后将第一位的指针后移

A E E L M [X S O P T R]      依

A E E L M O [S X P T R]　   次

A E E L M O P [X S T R]　　类

A E E L M O P R [S T X]　　推

A E E L M O P R S [T X]      .

A E E L M O P R S T [X]　　.

A E E L M O P R S T X []　　一直到循环结束。

 

 

3.代码实现（Java）

按照这个步骤，sort方法里面应该这样写：

/**
     * The function for sort with selection.
     * @param a
     */
    public static void sort(Comparable<String>[] a) {
        System.out.println("Before Begin");
        show(a);  //显示原始数组
        
        System.out.println("Begin:");
        
        
        // the first loop level
        for(int i = 0; i < a.length; i++) {
            int min = i;    //每一轮开始， 最开始指针后移
            
            // the second loop, find the smallest element in last array. and let min point to it.
            for (int j = i+1; j < a.length; j++) {
                if(less(a[j], a[min])) {
                    min = j;
                }
            }
            
            // change min element's place to last array's first place.
            exch(a, i, min);
            show(a);
        }
    }

可以看到，选择排序的逻辑还是比较简单的，就是从前向后，每一轮找出最小的放在最前面，一直到数组循环结束。

因此也决定了，选择排序的特性：数据移动最少。其移动次数是线性级别的。

下面是Java版本的全部代码：

package com.jacob.demo;

public class Selection {
    /**
     * The function for sort with selection.
     * @param a
     */
    public static void sort(Comparable<String>[] a) {
        System.out.println("Before Begin");
        show(a);
        
        System.out.println("Begin:");
        
        
        // the first loop
        for(int i = 0; i < a.length; i++) {
            int min = i;
            
            // the second loop, find the smallest element in last array. and let min point to it.
            for (int j = i+1; j < a.length; j++) {
                if(less(a[j], a[min])) {
                    min = j;
                }
            }
            
            // change min element's place to last array's first place.
            exch(a, i, min);
            show(a);
        }
    }
    
    /**
     * Compare if v is less than w.
     * @param v
     * @param w
     * @return
     */
    public static boolean less(Comparable<String> v, Comparable<String> w) {
        return v.compareTo((String) w) < 0;
    }
    
    /**
     * exchange two elements.
     * @param a
     * @param i
     * @param j
     */
    public static void exch(Comparable<String>[] a, int i, int j) {
        Comparable<String> t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    /**
     * Print array.
     * @param a
     */
    private static void show(Comparable<String>[] a) {
        for (int i= 0; i< a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
    
    /**
     * Judge if array is sorted
     * @param a
     * @return
     */
    public static boolean isSorted(Comparable<String>[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i-1])) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        String[] a = {"S","O","R","T","E","X","A","M","P","L","E"};
        sort(a);
        assert isSorted(a);
//        show(a);
    }

}

JS代码实现：

由于JS是弱类型的，因此其实现相对更简洁一些，无需再封装比较函数和显示函数。代码如下：

function selection(array) {
    let arr = array;
    for(i = 0; i < arr.length; i++) {
        let min = i;
        for (j= i+1; j < arr.length; j++) {
            if (arr[j] <= arr[min]) {
                min = j;
            }
        }
        exch(arr, i, min);
    }
}

function exch(array, firstIndex, minIndex) {
    let temp = array[firstIndex];
    array[firstIndex] = array[minIndex];
    array[minIndex] = temp;
}

function main() {
    var arr = [5,3,7,1,7,8,1];
    console.log(arr);
    selection(arr);
    console.log("after sort");
    console.log(arr);
}

以上就是今日一个小时左右的时间对选择排序的复习了。至于其性能，和时间以及空间复杂度，到后面再补充吧。希望自己不要忘记了。