交换排序总结（快排，冒泡）

一.交换排序类：

稳定排序：只进行元素间的顺序移动（相等的两数排序前和排序后次序相同）
1.冒泡排序 （时间复杂度 O（n^2） 稳定排序）
原理：比较相邻元素的大小 ，给定数组a[n],n个数据，

 **用 i 表示比较趟数，一共需比较 n-1 趟**

 **用 j 表示每趟相邻元素的比较次数，由于每趟即可确定一个元素位置所以比较次数会随着趟数的增加而减少 j 的变化可以为以下两种情况：（均为每次从前往后遍历）**

  **eg:        5  3  6  2 **
  **第一趟结果： 3   5  2  6
   其交换过程 ：（3 5 6 2）   （3 5 6 2）  （3 5 2 6）   **
  **第二趟结果： 3  2  5  6  （6 已经确定）
   其交换过程：（3 5 2） （3 2 5）      

 A>
 for(i=1;i<n;++i)  /*n-1趟*/
 { 
     for(j=0;j<n-i;++j)  //j+1 取到 n-i
     {
        if(a[j]>a[j+1])
           swap(&a[j],&a[j+1]);
     }
  }

 for(i=1;i<n;++i)
 { 
     for(j=1;j<=n-i;++j)
     {
        if(a[j-1]>a[j])
           swap(&a[j],&a[j+1]);
     }
  }

2.快速排序（时间复杂度O（N logN） 不稳定排序）
快排思想： 5 3 6 2
分治法：选首元素为轴记录 前low下标 后high下标 两个方向双向扫描遍历 大的值往后移 小的值往前移 将轴记录放到合适位置 轴记录元素分为两部分 再将前后分别进行快速排序

当high low指针指向的值被替换时指针移动
temp = 5    先比较后元素

 5        3         6          2  
low                           high
---> high 2 < 5

 2        3         6          2     
         low                  high

 2        3         6          2
                   low        high
---> low 6 > 5           
 2        3         6          6
                   low        high
 2        3         6          6
                 low high
 2        3         5          6
 //////////////////////分治法处理///////////

 分治法处理  2  3序列   和  6序列             

int main()
{
     ...
     int array[4] = {5,3,6,2};
     quitsort(array,0,3);
     ...
}
void quitsort(int *array,int left,int right)
{
     int index = 0;
     intdex = partition(a,left,right);
     quitsort(array,left,index-1);
     quitsort(array,index+1,right);
}
int partition(int *array,int left,int right)
{
     int temp = array[left];
     while(left < right)
     {
          while(left < right && array[right] >= temp)
               right--;
          if(left < right)
               array[left++] = array[right];

         while(left < right && array[left] < temp)
              left++;
         if(left < right)
              array[right--] = array[left];
     }
     array[left] = temp;
     return left;
}