排序算法的分类

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

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

1. 冒泡排序

    1     /**
    2      * 冒泡              O(n^2)
    3      * @param args
    4      */
    5     public static void BubbleSort(int[] args){
    6         int temp=0;
    7             for(int i=0;i<args.length;i++)
    8                 for(int j=0;j+i<args.length-1;j++)
    9                 {
   10                     if(args[j]>args[j+1])
   11                     {
   12                         temp=args[j+1];
   13                         args[j+1]=args[j];
   14                         args[j]=temp;
   15                     }
   16                 }
   17     }

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);}}