排序算法是最基本、最常见的一类算法。也是IT大公司常考的题目，这里花了一个晚上的时间总结了下，并都通过eclipse实现通过。关于各种算法的在哪些场合和改进之处，求各位大神赐教。

冒泡算法：冒泡算法的思路就是交换排序，通过相邻数据的交换达到排序的目的。平均速度为o（n2）.

public class BubbleSort {
   static final int SIZE=10;
   public static void BubbleSort(int[] a){
       int temp,i;
       for(i=1;i<a.length;i++){
           for(int j=0;j<a.length-i;j++){
               if(a[j]>a[j+1]){
                 temp=a[j];
                 a[j]=a[j+1];
                 a[j+1]=temp;
               }
           }
       System.out.print("第"+i+"步的排序结果：");
       for(int k=0;k<a.length;k++){
           System.out.print(" "+a[k]);
       }
       System.out.print("\n");
       }
   }

选择排序：选择排序在每一步选取最小的值来重新排列。平均速度为o（nlogn)。

class SelectSort{ 
        private int index;
        private int temp;
        public void selectSort(int[] a){
            for(int i=0;i<a.length-1;i++){
                index=i;
                for(int j=i+1;j<a.length;j++){
                    if(a[j]<a[index]){
                        index=j;//始终保持index代表最小值的索引
                    }
                }
                //交换当前比较的位置和最小索引的值
                if(i!=index){
                    temp=a[i];
                    a[i]=a[index];
                    a[index]=temp;
                }
                System.out.print("第"+(i+1)+"步的排序结果：");//输出每步结果便于观察
                for(int j=0;j<a.length;j++){
                    System.out.print(" "+a[j]);
                }
                System.out.print("\n");
            }
        }

插入排序：通过对未进行排序的数逐行插入到合适的位置。平均速度o(n2）。

public class InsertSort {
    static final int NUM_SIZE=10;
    private int j,t;
    public void insertSort(int[] a){
     for(int i=1;i<a.length;i++){
         t=a[i];      //t保存的是待插入的元素
         j=i-1;      //j是需要插入的位置
         while(j>=0&&t<a[j]){
            a[j+1]=a[j];
            j--;
         }         //通过while循环找到在t位置之前比t小的元素a[j],比t大的元素往后移
         a[j+1]=t; //在j的后一位插入待插元素t
         System.out.print("第"+(i)+"步的排序结果：");//输出每步结果便于观察
            for(int j=0;j<a.length;j++){
                System.out.print(" "+a[j]);
            }
            System.out.print("\n");
     }
    }

Shell排序：基于插入排序的思想。平均速度为o（n3/2)。

public class ShellSort {
    static final int NUM_SIZE=10;
    private int r,j,t;
    public void insertSort(int[] a){
        int x=0;
        for(r=a.length/2;r>=1;r/=2){ //分组排序
        for(int i=r;i<a.length;i++){
         t=a[i];      //t保存的是待插入的元素
         j=i-r;      //j是需要插入的位置
         while(j>=0&&t<a[j]){
            a[j+r]=a[j];
            j-=r;
         }         //通过while循环找到在t位置之前比t小的元素a[j],比t大的元素往后移r位
         a[j+r]=t; //在j的后r位插入待插元素t
     }            //Shell排序是在插入排序的基础上将距离由1增加到r；在各个的r个距离里实现插入排序，因此移动的数据少，效率高
         x++;
         System.out.print("第"+x+"步的排序结果：");//输出每步结果便于观察
            for(int j=0;j<a.length;j++){
                System.out.print(" "+a[j]);
            }
            System.out.print("\n");
     }
    }

快速排序：快速排序也是基于交换思想，是冒泡排序的改进。平均速度为o(nlogn)。

public class QuickSort {
  static final int NUM_SIZE=10;
  public void quickSort(int[] arr,int left,int right){
      int f,t;
      int ltemp,rtemp;
      ltemp=left;
      rtemp=right;
      f=arr[(left+right)/2];
      while(ltemp<rtemp){
          while(arr[ltemp]<f){
              ++ltemp;
          }
          while(arr[rtemp]>f){
              --rtemp;
          }
          if(ltemp<=rtemp){
              t=arr[ltemp];
              arr[rtemp]=arr[ltemp];
              arr[rtemp]=t;
              --rtemp;
              ++ltemp;
          }
      }
      if(ltemp==rtemp){
          ltemp++;
      }
      if(left<rtemp){
          quickSort(arr,left,ltemp-1);
      }
      if(ltemp<right){
          quickSort(arr,rtemp+1,right);
      }
  }
}

堆排序：其利用二叉树的一些性质和堆的数据结构完成数据的排序。

归并排序：将多个有序链表合并成一个有序的数据表。如果参与排序的只有两个有序链表，则称为二路合并。

 

桶式排序：桶式排序是一种很巧妙的排序方式，在有限制的数据范围内效率很高，能达到o（n）的时间复杂度，不过他的空间开销比较大，数据必须在一定范围内。

代码后续补充。