算法一：选择排序之直接选择

一、排序算法的衡量标准

时间复杂度：主要分析关键字的比较次数和记录的移动次数。

空间复杂度:分析排序算法中需要多少辅助内存

稳定性:若两记录A,B的关键值相等，但排序后A、B的先后次序保持不变，则称这种算法是稳定的。

二、常见排序算法

选择排序（直接选择排序，堆排序）。

交换排序（冒泡排序，快速排序）

插入排序（直接插入排序，折半插入排序，SHELL排序）

归并排序

桶式排序

基数排序

排序算法分类

直接选择排序:

原理：每一趟从待排序的记录中选出最大的元素，与数组最后一个元素互换位置，直到全部记录排序完毕

排序过程：

第一步：定义一个存放最大元素的变量max和其对应的下标index

第二步：max和数组中的元素做对比，如果max小于元素，则把元素值赋给max,元素索引赋给index

第三步：在本次循环结束后，把max和index和本轮的首个元素下标进行互换

第四步：重复一、二、三

代码：
倒序排列

  
private static void directSort(int[] data) {
        for(int i=0;i<data.length;i++){
            int max=data[i];
            int index=i;
            for(int j=i+1;j<data.length;j++){
                if(data[j]>max){
                    max=data[j];
                    index=j;
                }
            }
            int temp=data[i];
            data[i]=max;
            data[index]=temp;
            System.out.println("每次循环后的结果："+Arrays.toString(data));
        }
        System.out.println("最终结果："+Arrays.toString(data));
    }

优化：每次都取出最小值的索引，然后交换当前位置和最小值的位置的值即可.

   
 private static void betterDirectSort(int[] data) {
            int left=0;
            int right=data.length-1;
            int min=left,max=right;
            while(left<right){
                // 每次的窗口范围是left到right而不是一直是整个数组
                for(int j=left;j<=right;j++){
                    if(data[j]>data[max]){
                        max=j;
                    }
                    if(data[j]<data[min]){
                        min=j;
                    }
                }
    
                //最大的元素移到最右边，第二大的元素，放最右边元素的左边
                int tempmax=data[right];
                data[right]=data[max];
                data[max]=tempmax;
    
                // 最小的元素在最右边
                if(min ==right){
                    min=max;
                }
                //最小的元素移到最左边，第二大的元素，放最左边元素的右边
                int tempmin=data[left];
                data[left]=data[min];
                data[min]=tempmin;
                left++;
                right--;
                System.out.println("每次循环后的结果："+Arrays.toString(data));
            }
            System.out.println("最终结果："+Arrays.toString(data));
        }

时间效率:O(N*N),空间效率O(1),不稳定