各种排序算法

1直接选择排序：
每次将后面的最小的找出来插入前面的已排好的序中。同理，具有n个记录的序列要做n-1次排序。时间复杂度为O(n2)。

public void SelectSort(elemtype x[],int n)
{
   int i,j,Small;
   elemtype Temp;

   for(i=0;i<n-1;i++)
   {
      Small=i;
     
      for(j=i+1;j<n;j++)
      {
         if(x[j]<x[Small])
            Small=j;
      }

      if(Small!=i)
      {
        Temp=x[i];
        x[i]=x[Small];
        x[Small]=Temp;
      }
   }
}

2冒泡排序:
两个两个比较，将大的往后移。通过第一次冒泡排序，使得待排序的n个记录中关键字最大的记录排到了序列的最后一个位置上。要做n-1次排序。时间复杂度为O(n2)。

for (int i = 1; i < data.length; i++)
{
    //将相邻两个数进行比较，较大的数往后冒泡
    for (int j = 0; j < data.length - i; j++)
    {
         if (data[j] > data[j + 1])
         {
              //交换相邻两个数
              swap(data, j, j + 1);
         }
    }

}

3快速排序：
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按

次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 时间复杂度为O(nlog2n)。

public class QuickSort
{  
    public static int[] QuickSort0(int[] pData, int left, int right)
    {  
        int i= left, j= right;  
        int middle, strTemp;  
 
        middle = pData[(left + right) / 2];  
        do
        {  
            while ((pData[i] < middle) && (i < right))  
                i++;  
            while ((pData[j] > middle) && (j > left))  
                j--;  
            if (i <= j)
     {  
                strTemp = pData[i];  
                pData[i] = pData[j];  
                pData[j] = strTemp;  
                i++;  
                j--;  
            }  
        }
        while (i <= j);  

        if (left < j)
        {  
            QuickSort0(pData, left, j);  
        }  
 
        if (right > i)
        { 
            QuickSort0(pData, i, right);  
        }

        return pData;  
    }  
 
    public static void main(String[] argv)
    {  
        int[] pData = { 1,84, 85, 67,600, 88,999 };  
        QuickSort0(pData, 0, pData.length - 1);  
    }  
} 

4插入排序：
将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。

for (int i = 1; i < data.length; i++)
{
     //保证前i+1个数排好序
     for (int j = 0; j < i; j++)
     {
         if (data[j] > data[i])
         {
             //交换在位置j和i两个数
             swap(data, i, j);
         }
     }
}