排序(一)

1.冒泡排序
void BubbleSort(ElemType a[],int n){

    for(i=0;i<n-1;i++){
       flag=false;                 //交换标志
       for(j=n-1;j>i;j--)
         if(a[j-1].key<a[j].key){
            swap(a[j-1],a[j]);
            flag=true;             //发生交换
           }
        if(flag=false)
           return;       //没有发生交换，则本身有序，直接返回
     }
}
最简单、直接，算法稳定。
时间复杂度O(n^2),空间复杂度O(1)


2.快速排序

void QuickSort(ElemType a[],int low,int high){
   if(low<high){

       int pivotpos=Partition(a,low,high);  //划分子表
       QuickSort(a,low,pivotpos-1);         //递归调用，需要递归栈
       QuickSort(a,pivotpos+1,high);
     }
}
int Partition(ElemType a[],int low,int high){
   ElemType pivot=a[low];         //以第一个值为枢纽值
   while(low<high){
      while(low<high&&a[high]>=pivot)  --high;
      a[low]=a[high];
      while(low<high&&a[low]<=pivot)   ++low;
      a[high]=a[low];

   }
    a[low]=piovt;
    return low;              //返回存放枢纽值的最终位置
}
时间复杂度O(nlogn)空间复杂度O(logn)
理想情况下每次平均划分，以空间换时间，内部排序性能最优