直接选择排序

选择排序的思想：选出最小的一个和第一个位置交换，选出其次小的和第二个位置交换 ……直到从第N个和第N-1个元素中选出最小的放在第N-1个位置，简单的说就是每次排序都是从未排序的数组中选择最小的，放到已经排序的数组的最后；
Java代码实现：

package selection;
public class selection {
    public static int[] selection1(int []arr)
    {
        int minIndex=0;
        int temp=0;
        //假如数组为空，或者数组中只有一个数，则不用排序，直接返回
        if(arr==null||arr.length<2)
        {
            return arr;
        }
        //外面的for循环代表未排序数组中最小数字要交换的位置
        for(int i=0;i<arr.length-1;i++)
        {
            minIndex=i;
            //每次都找未排序中最小的那个数
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[j]<arr[minIndex])
                {
                    minIndex=j;
                }
            }

            if(minIndex!=i)
            {
                temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
            for(int n=0;n<arr.length;n++)
            {
                System.out.print(arr[n]+" ");
            }
            System.out.println();
        }
        return arr;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]={23,2,3,7,4,1,10};
        for(int n=0;n<arr.length;n++)
        {
            System.out.print(arr[n]+" ");
        }
        System.out.println();
        System.out.println();
        int arr1[]=selection1(arr);
        System.out.println();
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+" ");
        }


    }

}

结果为：
23 2 3 7 4 1 10

1 2 3 7 4 23 10
1 2 3 7 4 23 10
1 2 3 7 4 23 10
1 2 3 4 7 23 10
1 2 3 4 7 23 10
1 2 3 4 7 10 23

1 2 3 4 7 10 23
选择排序的时间复杂度：O(n*n)
交换时间：最好的情况全部元素已经有序，则交换次数为0；最差的情况，全部元素逆序，就要交换 n-1 次；所以最优的时间复杂度和最差的时间复杂度和平均时间复杂度都为：O(n*n)
稳定性：不稳定
空间复杂度，最优的情况下（已经有顺序）复杂度为：O(0) ；最差的情况下（全部元素都要重新排序）复杂度为：O(n );平均的时间复杂度：O(1)