Java 一些常见的 排序算法 面试也会问的算法

小白工作两年，基本上没有用到排序算法，也没有用到很高深的数据结构，也许可能是我从事的Java web的开发，如果从事的是游戏的开发或者是胖客户端的开发，一定会用到一些排序啊，算法什么的，不管怎样，作为一个软件工作者，大大小小的排序算法和数据结构该会一点吧，至少可以应付一下笔试，好了，废话不多说了，直接上代码，以后有用的话直接复制就好了，也搞不懂笔试为什么要写算法，这种不好记代码啊，要用的是百度不就行了吗？已经很成熟了，我们直接拿过来用啊

冒泡排序 有两层循环，外层递减，内层递增，每一趟都会得到最大的值，因为存在连个for循环，基本上每趟循环都会交换N次，所以一共交换N的平方次，所以时间复杂度为O(N2)，属于效率最差的算法

      public static void pop( int a []){

          int temp ;

          for ( int i = a . length -1; i >0; i --){

               for ( int j = 0; j < i ; j ++){

                   if ( a [ j ]> a [ j +1]){

                        // 交换 a[j] 和 a[j+1]

                        temp = a [ j +1];

                        a [ j +1] = a [ j ];

                        a [ j ] = temp ;

                  }

              }

         }

     }

选择排序 就是冒泡排序的改进版，首先选出一个最小的元素放在数组最左边，然后下一趟再选出最小的一个放到左边第二个位置上，以此类推

两层for循环，从第一个位置开始，里面的一层循环得到这一趟中最小的下标min，然后记录下来，得到后就判断该min和开始位置的下标是否相等，如果不相等，就把他们交换。

      public static void select( int a []){

          int min , temp ;

          for ( int i = 0; i < a . length ; i ++){

               min = i ;  // 每一趟左边的是排好序的，是最小的

               for ( int j = i +1; j < a . length ; j ++){

                   if ( a [ j ]< a [ min ]){

                        // 1 记录最小的位置

                        min = j ;

                  }

              }

               // 现在min值得就是最小树的下标，现在判断min和i（i是最左边的位置）的值，

               // 如果不相等，就最最小的数和开始第一位交换

               if ( min != i ){

                   temp = a [ i ];

                   a [ i ] = a [ min ];

                   a [ min ] = temp ;

              }

         }

     }

选择排序和冒泡排序的时间复杂度是一样的为O(N2)N的平方，但是交换的次数少了，10个数据，最多只需要交换10次。

插入排序

      public static void insert( int a []){

          int out , in ;

          for ( out = 1; out < a . length ; out ++){

               int temp = a [ out ]; // 记录被选择的这个元素的值

               in = out ; // 记录被选择的元素的下标 然后用a[in-1] 和 in-- 来逐个获得被标记元素的前面的元素

               while ( in >0&& a [ in -1]> temp ){

                   a [ in ] = a [ in -1];

                   in --;

              }

               a [ in ] = temp ;

         }

     }

主要思路： 先认为第1个元素是排好序的，然后选择第二个元素作为标记位temp,然后temp和前面的元素进行比较，如果前面的元素比temp大，那么就把前面的元素后移一个位置，最后当发现前面的元素不比temp大的时候，就把temp放在这个元素的位置上，实际上这个后移的操作。

快速排序代码

public static int partition( int [] array , int lo , int hi ){

         int key = array [ lo ];

         while ( lo < hi ){

             // 从右边向左检查，找到一个比基准值小的第一个位置 为 hi

             while ( array [ hi ]>= key && hi > lo ){

                 hi --;

            }

             array [ lo ] = array [ hi ];

             while ( array [ lo ]< key && lo < hi ){

                 lo ++;

            }

             array [ hi ] = array [ lo ];

        }

         array [ hi ] = key ;

        pir( array );

         return hi ;

    }

     public static void fast( int [] array , int lo , int hi ){

         if ( lo >= hi ){

             return ;

        }

         int index = partition( array , lo , hi );

        fast( array , lo , index -1);

        fast( array , index +1, hi );

    }

    

算法思想：基于分治的思想，是冒泡排序的改进型。首先在数组中选择一个基准点（该基准点的选取可能影响快速排序的效率，后面讲解选取的方法），然后分别从数组的两端扫描数组，设两个指示标志（lo指向起始位置，hi指向末尾)，首先从后半部分开始，如果发现有元素比该基准点的值小，就交换lo和hi位置的值，然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换lo和hi位置的值，如此往复循环，直到lo>=hi,然后把基准点的值放到hi这个位置。一次排序就完成了。以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

希尔排序


 void Shell_Sort(int a[], int n)   n是数组的size();
{   
     int h,i,j,temp;   
    for (h=n/2; h>0; h=h/2)   
    {   
         for (i=h; i<n; i++)   
         {   
             temp = a[i];   
             for (j=i-h; j>=0 && temp < a[j]; j-=h)   
             {   
                 a[j+h] = a[j];   
             }   
             // 注意，这里的j已经被减过一个h 了，一般为负数，所以 j+h = j 回到之前的值
             a[j+h] = temp;   
         }   
     }   
        
 }
// 就先写到这里吧，后面有时间再补充