基础排序（一）

简单记录下 O(n^2)时间复杂度的三个排序算法。

1.选择排序

 选择排序主要实现思路：

 每执行一次内层for循环，找到最小值索引，与外层for循环 i 对应数组的当前值交换。

public static void selectSort(int []arr){
         for(int i=0;i<arr.length;i++)
        {      int Mindex=i;
            for(int j=i+1;j<arr.length;j++)
            {       if(arr[Mindex]>arr[j])   Mindex=j;}
                    if(i!=Mindex)
             {        int temp=arr[i]; 
                      arr[i]=arr[Mindex];
                      arr[Mindex]=temp;
             }
        }                                   }

下面简单列举，使用泛型情形下的选择排序。compareTo方法适用于Char，Double，Integer等类型。

public static <T extends Comparable<? super T>> void selectSort(T[] arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            T minItem = arr[i];
            int MIndex = i;
            for(int j = i + 1; j < arr.length; j++)
            {
                if (arr[j].compareTo(minItem) < 0)
                {
                    minItem = arr[j];
                    MIndex = j;
                }
            }
            arr[MIndex] = arr[i];
            arr[i] = minItem;
        }
        for (T t : arr) {
            System.out.print(t+" ");
                            }
    }

2.插入排序

插入排序主要实现思路：

从第二个数开始，对比前面的数字，小值就往左移。不断构建有序环境。
优势在于可以提前终止内层循环。初版由于交换次数执行过多，效率不如选择排序。

     public static void insertSort(int[] arr ){
        for(int i=1;i<arr.length;i++)
            for(int j=i;j>0;j--)
            {
                     if(arr[j]<arr[j-1])
                {        int temp=arr[j]; 
                         arr[j]=arr[j-1];
                         arr[j-1]=temp;
                }
                else{
                    break;
                }
            } }
    

在有序环境下，插入排序的效率是最高的。优化后：

记录下外层for循环索引i的数值，内层循环不采用交换的方式，直接赋值替换数据，最后用将值arr[i]插入内循环的终点处。

public static void insertSortT(int[] arr ){
        for(int i=1;i<arr.length;i++)
          {    int E= arr[i]; 
               int j;       
            for( j=i;j>0&&E<arr[j-1];j--)  
            {
                  arr[j]=arr[j-1];
            }
                arr[j]=E;                
            }
        }

3.冒泡排序

 没什么思路，两两交换。把最大值移动到末尾。

       public static void MpSortF(int arr[]){
             int n=arr.length;
         for(int i=0;i<n;i++){
         for(int j=0;j<n-i-1;j++)
          {
              if(arr[j]>arr[j+1])
              {
                  int temp=arr[j]; 
                  arr[j]=arr[j+1];
                  arr[j+1]=temp;
              }
          } }