冒泡排序，快速排序

           交换排序指根据序列中两个元素关键字的比较结果来兑换这两个记录在序列中的位置。（个人觉得这个定义很坑）

           下面介绍两种较为常见的排序方法：冒泡排序，与快速排序

           冒泡排序：从前往后（或从后往前）依次比较相邻元素，若为逆序，则交换相邻元素。每次都能将（最大或者最小）元素放到正确的位置上。这样至多n-1次排序，就能将所有元素依次排序好。冒泡排序在最坏情况下，是所有元素为逆序，每趟都要比较n-i次，时间复杂度为O(n^2),而在最好情况，所有元素已经有序，需要比较n-1次。

          

void BubbleSort(int *ar,int length)                   \\递增排列
{
         bool flag;                 \\起标记最用，判断序列是否已经有序
         int i；
         for(i=0:i<=length;i++)
         {    
                 flag=false;
                 for(j=0;j<=length-1;j++)
                 {
                         if(ar[i-1]>ar[i])
                         {
                                  swap(ar[i-1],ar[i]);                     \\逆序则交换顺序
                                  flag=true;

                          }
                 }
          }
         if(flag==flase)
               return 1;
}
</span>

          快速排序：基本思想基于分治法：在待排序序列中任取一个元素作为基准，通过一趟排序，将待排序序列，划分为独立的两部分，然后分别对两个子序列进行递归。下面程序划分部分的思想就是： 记录元素中第一个大于基准元素的位置，而与后面第一个小于基准元素的位置相交换，这样就保证在i（记录位置）以前元素全小于基准元素.

int Quicksort(int *ar,int low,int high)
{
        int position;
        if(low<high)
        {
                   position=Partition(ar,low,high);                 //将序列划分为两独立序列
                   Quicksort(ar,low,position-1);                    //分别对子序列递归排序
                    Quicksort(ar,position+1,high);
        }
}
int Partition(int *ar,int low,int high)
{
        int key;
        int i;                                                //记录第一个大于key的元素的位置
        int j;
        i=low-1;
        for(j=low;j<=high;j++)
        {
              key=ar[high];
              if(ar[j]<key)                                    //将序列中第一个大于key的元素与之后遇到第一个小于key 
                                                               //的元素交换位置
              {
                     i++;
                     swap(&ar[i],&ar[j])
              }
        }
        swap(&ar[high],&ar[i+1]);
        return i+1;
}
</span>

                在快速排序中，程序的时间复杂度，与选择基准元素，以及递归划分有关，在最好情况下，O（n*log2n）