数组排序-冒泡排序-选择排序-插入排序-希尔排序-快速排序-Java实现

这五种排序算法难度依次增加。

冒泡排序:

第一次将数组相邻两个元素依次比较，然后将大的元素往后移，像冒泡一样，最终最大的元素被移到数组的最末尾。

第二次将数组的前n-1个元素取出，然后相邻两个元素依次比较，将大的元素往后移，最终n-1个元素中最大的元素又在末尾。

重复上面的步骤，直到数组只有1个元素为止。因为每次都将上一次比较剩下的最大元素放到末尾，所以当所有比较结束的时候，排序结束。

     public void bubbleSort(T[] array)
     {
         for(int i = array.length-1;i>0; i--)
         {
             for(int j = 0; j <i; j++)
             {
                 if(array[j].compareTo(array[j+1]) > 0)
                 {
                     T temp = array[j];
                     array[j] = array[j+1];
                     array[j+1] = temp;
                 }
             }
         }
     }

二)选择排序

选择排序和冒泡排序类似，只是每次循环的时候将最大的元素位置记下来，然后当循环结束的时候，将最大的元素与最末尾元素进行调换。这样，当所有循环结束的时候，数组排序也结束。

     @Override
     public void selectionSort(T[] array)
     {
         for(int i = array.length-1; i>0; i--)
         {
             int max = 0;
             for(int j = 0; j <= i; j++)
             {
                 if(array[max].compareTo(array[j]) < 0)
                 {
                     max = j;
                 }
             }

             T temp = array[max];
             array[max] = array[i];
             array[i] = temp;
         }
     }

三）插入排序

插入排序的思想是遍历整个数组，从第一个元素开始，在遍历过程中将该元素与之前元素比较，将它插入到之前元素的中间，要求是该元素大于前面所有元素，且小于等于后面所有元素。

     @Override
     public void insertionSort(T[] array)
     {
         this.insertionSort(array,0,array.length);
     }

     @Override
     public void insertionSort(T[] array, int start, int length)
     {
         for(int i = start; i < start+length;i++)
         {
             for(int j = start; j < i; j++)
             {
                 if(array[i].compareTo(array[j]) < 0)
                 {
                     T temp = array[i];
                     for(int k = i; k > j; k--)
                     {
                         array[k] = array[k-1];
                     }
                     array[j] = temp;
                 }
             }
         }
     }

四）希尔排序

希尔排序是插入排序的升级版。希尔排序会设置一个步长gap，然后不断减小gap，直到gap为1。而每次将数组中长度为gap的元素进行排序。其实就是先对数组进行局部排序，使得数组在总体上有序的，这样在插入排序的时候就不需要进行大规模的数据移动。

     @Override
     public void shellSort(T[] array)
     {
         int gap = array.length/2;
         while(gap >=1)
         {
             for(int i = gap; i<array.length; i++)
             {
                 this.insertionSort(array, i-gap, gap+1);
             }
             gap = gap/2;
         }
     }

五）快速排序

快速排序会使用到分治法和递归思想。每次排序的时候，选取一个元素，将所有小于它的元素放到左边，将所有大于它的元素放到它的右边。然后将左边和右边的元素分别看成一个数组，然后递归将剩余的元素按照之前的方式排序。当数组长度为1的时候，递归结束，整个数组排序也完成。

     @Override
     public void quickSort(T[] array)
     {
         this.quickSortInternal(array, 0, array.length-1);
     }

     private void quickSortInternal(T[] array, int left, int right)
     {
         if(left >= right)
         {
             return;
         }

         int _left = left;
         int _right = right;

         boolean flag = false;
         while(left!=right)
         {
             if(flag == false)
             {
                 //从右向左逼近
                 if(array[right].compareTo(array[left]) < 0)
                 {
                     T temp = array[left];
                     array[left] = array[right];
                     array[right] = temp;
                     //交换后 应该调换方向
                     flag = !flag;
                 }
                 right--;
             }
             else
             {
                 //从左向右逼近
                 if(array[left].compareTo(array[right]) > 0)
                 {
                     T temp = array[left];
                     array[left] = array[right];
                     array[right] = temp;
                     //交换后 应该调换方向
                     flag = !flag;
                 }
                 left++;
             }
         }
         //递归
         this.quickSortInternal(array, _left, left-1);
         this.quickSortInternal(array, right+1, _right);
     }
 }