public static int[] sort(int[] nums) {
    int size = nums.length;
    int tmp;
    for (int i = 0; i < size; i++) {
      for (int j = i; j < size; j++) {
        if (nums[i] > nums[j]) {
          tmp = nums[i];
          nums[i] = nums[j];
          nums[j] = tmp;
        }
      }
    }
    return nums;
  }

public static int[] directInsertSort(int[] nums) {
    // 已经排序的长度
    int leng = 1;
    // 标记
    int mark;

    for (int i = 1; i < nums.length; i++) {
      mark = nums[leng];// 将未排序列的第一个元素暂存
       if (nums[i] < nums[i - 1]) {// leng处小于已排序部分的最大数，需要插入
         for (int j = 0; j < leng; j++) {// 将mark插入已排序部分的适当位置
           if (mark <= nums[j]) {// mark不大于nums[j]
            for (int k = leng - 1; k >= j; k--) {// 移动
              nums[k + 1] = nums[k];
          }
          nums[j] = mark;
          break;// 跳出
         }
       }
      }
      leng++;// 已排序部分的长度加1
    }// for
    return nums;
  }

public static int[] sort(int[] nums) {
        Arrays.sort(nums);
        return nums;
    }

Function QSort(nums)
        Dim L, R, tmp 
        L = 1
        R = ubound(nums)   'Get the arrays length
        tmp = nums(L)

        Do Until L >= R 
                While (Data(R) > tmp And R > L) 
                        R = R - 1 
                Wend 
                If R > L Then 
                        Data(L) = Data(R) 
                        Data(R) = tmp 
                        L = L + 1 
                End If 
                While (Data(L) < tmp And R > L) 
                        L = L + 1 
                Wend 
                If R > L Then 
                        Data(R) = Data(L) 
                        Data(L) = tmp 
                        R = R - 1 
                End If 
        Loop 
QSort = nums
End Function 

public class MarquisSort
{
    private static int[] resultData;
    
    public static void main( String[] args )
    {

        int MAX = 100000;
        int[] nums = new int[ MAX ];
        Random r = new Random( 20080623 );
        for( int i = 0; i < MAX; i++ )
        {
            nums[ i ] = r.nextInt( MAX );
        }
        long begin = System.currentTimeMillis();
        int[] data = sort( nums );
        long end = System.currentTimeMillis();
        System.out.println( ( end - begin ) ); // 以这个时间为标准，越小越好。
        
    }

    public static int[] sort( int[] nums )
    {

        // 您的排序代码放在这里啦
        resultData = new int[nums.length];
        countingSort( nums, resultData, getMaxInt( nums ) );
        return resultData;
    }
    
    private static int getMaxInt( int[] data )
    {
        int max = 0;
        for( int i : data )
        {
            if( i > max )
            {
                max = i;
            }
        }
        return max;
    }
    
    private static void countingSort( int[] oriData, int[] resultData, int k )
    {
        int[] assistData = new int[ k + 1 ];
        
        for( int i = 0; i < assistData.length ; i++ )
        {
            assistData[ i ] = 0;
        }
        
        for( int j = 0; j < oriData.length ; j++ )
        {
            assistData[ oriData[ j ] ] = assistData[ oriData[ j ] ] + 1;
        }

        for( int i = 1; i < assistData.length ; i++ )
        {
            assistData[ i ] = assistData[ i ] +  assistData[ i - 1 ];
        }

        for( int j = oriData.length - 1  ; j >= 0 ; j-- )
        {
            resultData[ assistData[ oriData[ j ] ] - 1 ] = oriData[ j ];
            assistData[ oriData[ j ] ] = assistData[ oriData[ j ] ] - 1;
        }    
    }

}

  /**
   * 快速排序法
   * 
   * @param array
   * @param star
   *          将要进行快速排序的第一个元素位置(下标)
   * @param end
   *          将要进行快速排序的最后一个元素位置(下标)
   */
  public static void quickSort(int[] array, int star, int end) {
    // 记录原来的位置
    int priStar = star;
    int priEnd = end;
    if (star == end) {// 只有一个元素
      return;
    } else {
      int key = array[star]; // 以第一个元素作为关键数据
      int tem = 0; // 交换数据时用所的中间变量
      while (star < end) {
        while (star < end && array[end] >= key) {// 从最后一个元素开始找第一个比key小的元素
          end--;
        }
        if (star != end) {// 两都不等，说明找到,交换
          tem = array[star];
          array[star] = array[end];
          array[end] = tem;
        }
        while (star < end && array[star] <= key) {// 从第一个元素开始找第一个比key大的元素
          star++;
        }
        if (star != end) {// 两都不等，说明找到,交换
          tem = array[star];
          array[star] = array[end];
          array[end] = tem;
        }
      }// while
      if (priStar < star - 1) { // 如果关键值不是处于第一位，则对关键值前一部分进行递归排序
        quickSort(array, priStar, star - 1);
      }
      if (priEnd > end + 1) { // 如果关键值不是牌最后一位，则对关键值后面的部分进行递归排序
        quickSort(array, end + 1, priEnd);
      }
    }
  }