从入门开始手把手搭建千万级Java算法测试-选择排序

  第二天开始呢，我们讲解选择算法，从算法思路，到算法伪代码实现，到复杂度分析，从这里开始我们手把手搭建一个测试平台的基础，根据你自身硬件水平可以对下列代码进行从1000，到千万级测试，其中算法测试时间与你的机器硬件水平和实现的算法有关系，下面是选择算法的具体讲解。
（1）排序算法的思路并且举例说明
  选择排序基本思想：从头至尾扫描序列，找出最小的一个元素，和第一个元素交换，接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。
例如： 5 6 3 2 4 1
第一次排序： 1 5 6 3 2 4
第二次排序： 1 2 5 6 3 4
第三次排序： 1 2 3 5 6 4
第四次排序： 1 2 3 4 5 6

（2）算法伪代码

	for (i = 1; i <= n - 1; i++) {
		smallest = i;
		for (j = i + 1; j <= n; j++)
			if (S[j] < S[smallest]){
				smallest = j;
				}
		exchange S[i] and S[smallest];
	}

（3）复杂度分析
平均时间复杂度：O(n2)
   使用了for循环两次的选择排序，其中外循环完成是数据交换，内层循环完成是数据比较，所以我们分别统计数据交换次数和数据比较次数：
数据比较次数：(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
数据交换次数：N-1
时间复杂度：N2/2-N/2+（N-1）=N2/2+N/2-1;
根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2);大。

最好时间复杂度：O(n2)
最差时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：不稳定
（4）代码主体部分

package runoob;

/**
 * 选择排序
 */
public class SelectionSort {

    public static void sort(int[] arr){
        int n = arr.length;
        for( int i = 0 ; i < n ; i ++ ){
            // 寻找[i, n)区间里的最小值的索引
            int minIndex = i;
            for( int j = i + 1 ; j < n ; j ++ )
                if( arr[j] < arr[minIndex] )
                    minIndex = j;//数据交换不同索引位置数据
            swap( arr , i , minIndex);
        }
    }
    private static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void SelectionSort_text(long num) {
        long start,end;
        Integer[] arr = SortHelper.generateRandomArray(num, 0, 100000);//随机生成数组
        start = System.currentTimeMillis();
        InsertionSort.sort(arr);
        end = System.currentTimeMillis();
        System.out.println("花费时间:" + (end - start) + "(ms)");
        System.out.println("下面是排序好的数列");
        SortHelper.printArray(arr);
    }
}

  对应代码中的SortHelper类我们留一个小小的悬念，留到最后来进行叙说，其中目前来说他的方法generateRandomArray的参数为，（num，left，right）第一个参数参与算法生成的数量级，作为随机生成序列，它可以为千万，因为是long级别，left和right则为生成序列的大小范围，生成的序列为返回值类型为Integer[]。
（5）测试结果如下：

  因为选择算法的时间复杂度比较高，如果笔者有兴趣可以尝试千万级的算法测试，这里便不在赘述。