常用排序算法及其实现

排序算法的分类

1. 插入排序（直接插入排序，折半插入排序，希尔排序）
2. 交换排序（冒泡排序，快速排序）
3. 选择排序（直接选择排序，堆排序）
4. 归并排序
5. 基数排序

 冒泡、直接选择排序、直接插入排序为简单排序。也是最容易掌握和理解的。

1. 冒泡排序

       /**
        * 冒泡              O(n^2)
        * @param args
        */
       public static void BubbleSort(int[] args){
           int temp=0;
               for(int i=0;i<args.length;i++)
                   for(int j=0;j+i<args.length-1;j++)
                   {
                       if(args[j]>args[j+1])
                       {
                           temp=args[j+1];
                           args[j+1]=args[j];
                           args[j]=temp;
                       }
                   }
       }

2. 选择排序

       /**
        * 选择排序        O(n^2)
        */
       public static void SelectionSort(int[] a)
       {
           for(int i=0;i<a.length;i++){
               int k=i;
               for(int j=i+1;j<a.length;j++){
                       if(a[k]>a[j])
                           k=j;
               }
               if(k!=i){
                   int temp=a[k];
                   a[k]=a[i];
                   a[i]=temp;
               }
           }
       }

    

3. 插入排序

       /**
        * 直接插入排序        O(n^2)
        * 局部有序扩展到全部有序。
        */
       public static void insertionSort(int[] a ){
           
           int in,out;   //in为有序区指针变量，out为无序区指针变量
           for( out=1;out<a.length;out++)        
           {
               int temp=a[out];
               in = out;                //把out所指位置归入到有序区，然后进行有序区排序
               while(in>0&&temp<a[in-1])
               {
   //                System.out.println("a[in]:"+a[in]+"---in:"+in);
                   a[in]=a[in-1];
                   --in;
                   
               }
               a[in]=temp;
   //            for(int i=0;i<a.length;i++)
   //                System.out.println(+a[i]+"---");
           }//end ---for        
       }

    

4. 快速排序

       /**
        * 
        * 划分算法（快速排序的基础）
        * @param a
        * @param pivot
        */
       
       public static int partitionIt(int[] a ,int l,int r,int pivot){
           int leftPtr,rightPtr,left,right;
           
           left=l;      
           right=r;
           leftPtr=left-1;            //leftPtr用于最终指向的比pivot大数(包括本身)
           rightPtr=right;            //rightPtr用于最终指向的比pivot小的数(包括本身)
           System.out.println("\npivot--->left--->right--->:"+pivot+"--->"+left+"--->"+right);
           while(true){
           while(a[++leftPtr] < pivot)                        
                       ;
               while(rightPtr > left && a[--rightPtr] >pivot)
                   ;
                       if( rightPtr <= leftPtr )
                           break;
                       else{
                           int temp=a[rightPtr];
                           a[rightPtr]=a[leftPtr];
                           a[leftPtr]=temp;    
                       }
           }//end while(true)
           //把枢轴上的数插入到全排序后所对应的位置
           //（因为leftPtr最终指向是大于枢轴的数（包括本身），交换后则可以保证leftPtr所在位置的右边的数都比枢轴大，左边同理，都比枢轴小,即最终位置就是leftPtr）
                       int temp2=a[leftPtr];
                       a[leftPtr]=pivot;
                       a[right]=temp2;    
       
           return leftPtr;
       }
       /**
        * 
        * 快速排序
        * @param a
        * @param lp  数组的左边界
        * @param rp  数组的右边界
        */
       public static void quickSort(int[] a,int lp,int rp){
           
           if(lp>=rp)
               return;
           else{
               int pivot=a[rp];        //取最右边的值作为枢轴
               int partition=partitionIt(a, lp, rp,pivot);
               quickSort(a,lp,partition-1);
               quickSort(a,partition+1,rp);
               
           }
       }