快速排序

    /**
    * 第一次划分大小
    * @param array
    * @param start
    * @param end
    * @return 扫描完毕指针的位置
    */
    public int once(int[] array,int start,int end){
        int i= start, j= end, temp=0;
        while( i< j){
            //右侧扫描
            while( i< j && array[ i]<= array[ j])
            j--;
            //较小的数置于前面
            if( i< j){
                temp= array[ i];
            array[ i]= array[ j];
            array[ j]= temp;
            i++;
                 }
            //左侧扫描
            while( i< j && array[ i]<= array[ j])
            i++;
        //较大的数置于后面
        if( i< j){
            temp= array[ i];
            array[ i]= array[ j];
            array[ j]= temp;
            j--;
        }
       }
        return i; //返回记录的位置
    }

    public void quickSort( int[] array, int start, int end){
        //int location;
        if( start< end){
            int location = once( array, start, end);
            quickSort( array, start, location-1);
            quickSort( array, location+1, end);
        }
    }

冒泡排序

     /**
      * 冒泡排序算法
      * @param array 待排序数组
      */
     public void bubble(int[] array){
        for( int i=1; i< array.length; i++)
            for( int j=0; j< array.length- i; j++){
                if( array[j]> array[j+1]){
                    int t = array[j];
                    array[j] = array[j+1];
                    array[j+1] = t;
                }
            }
        }
    }

堆排序

    //筛选法调整堆
    public void Sift(int r[], int k, int m){
        int i, j, temp;
        i= k;
        j=2* i+1; //置i为要筛的结点，j为i的左孩子
        while (j<=m){
            if (j< m && r[j] < r[j+1])
                  j++; //比较i的左右孩子，j为较大者
            if (r[i]> r[j]) 
                break; //根结点已经大于左右孩子中的较大者
            else{
                temp = r[i];
                r[i] = r[j];
                r[j] = temp; //将根结点与结点j交换
                i = j;
                j = 2*i+1; //被筛结点位于原来结点j的位置
            }
        }
    }
    //堆排序
    public void heapSort(int r[ ], int n){
        int i;
        int temp;
        //初始建堆，从最后一个非终端结点至根结点
        for (i=n/2; i>=0; i--)
          Sift( r, i, n);
        //重复执行移走堆顶及重建堆的操作
        for (i=n-1; i>0; i--){
              temp= r[ i];
              r[ i]= r[0];
              r[0]= temp;
           Sift( r, 0, i-1);
        }
    }

选择排序

    /**
    *
    * @param array 待排序数组
    * @param n 数组长度
    */
    public void selectSort( int[] array, int n){
        /**
        * i 无序区中第一个位置
        * j 中间变量
        * index 无序区中第一个位置，用于与无序区的其他r[j]进行比较
        * temp 用于交换变量
        */
        int i, j, index, temp;
        //对n个记录进行n-1趟简单选择排序
        for (i=0; i< n-1; i++){
            index = i;
            //在无序区中选取最小记录
            for (j= i+1; j< n; j++)          
                if (array[j] < array[index])
            index = j;
            if (index!= i){
                temp = array[i];
                array[i]= array[index];
                array[index]= temp;
            }
        }
    }

归并排序(待续...)

如发现错误，还望不吝指正为谢~