交换类排序算法

#include<stdio.h>
/*
*交换类排序，每天一道算法题 
*按照从小到大的顺序进行排序 
* 毛施平
*/
//冒泡排序 
void traverseArray(int *p,int length)
{
   int i=0;
   for(;i<length;i++)
   {
     printf("%d\n",p[i]);
   } 

}
//这个是最简单的 
void bubbleSortOne(int *p,int length)
{
  int i=length;
  int j,temp;
  int lastChangeIndex;
  printf("简单一点：\n");
  while(i>1)
  {
   lastChangeIndex=1;
    for(j=0;j<i-1;j++)
    {
       if(p[j]>p[j+1])
       {
        temp=p[j];
        p[j]=p[j+1];
        p[j+1]=temp;
        lastChangeIndex=j;
       }
    }
   traverseArray(p,9);
   printf("\n");
   i=lastChangeIndex;
  } 
} 
//这个排序并不是最简单的 
void bubbleSort(int *p,int length)
{
  int i,j,temp;
  for(i=0;i<length;i++)
  {
    for(j=0;j<length-i-1;j++)
    {
       if(p[j]>p[j+1])
       {
        temp=p[j];
        p[j]=p[j+1];
        p[j+1]=temp;
       }
    } 
  }
} 
//快速排序 
int Partition(int *p,int low,int high)
{
  //int low=0,high=length-1;
  int temp=p[low];
  while(low<high)
  {
    while(low<high&&p[high]>=temp) high--;
       p[low]=p[high];
    while(low<high&&p[low]<=temp) low++;
       p[high]=p[low]; 
  }
  p[low]=temp;
  return low;
} 
void QSort(int *p,int low,int high)
{
  if(low<high)
  {
   int pivotloc=Partition(p,low,high);
   traverseArray(p,9);
   printf("\n"); 
   QSort(p,low,pivotloc-1);
   QSort(p,pivotloc+1,high);
  }


}

int main()
{
  int a[]={9,2,1,4,5,7,3,8,6}; 
  bubbleSortOne(a,sizeof(a)/sizeof(int));
  int low=0;
  int high=sizeof(a)/sizeof(int)-1; 
 // QSort(a,low,high);
  traverseArray(a,sizeof(a)/sizeof(int));
  
  system("pause");
  return 0;
}

冒泡排序和快速排序都属于交换类排序，最简单的冒泡排序需要考虑顺序基本确定以后，如果不需要调整的话，需要设置标志位，避免不进行交换的重复比较。冒泡排序如果正序，只需要比较n-1次，不需要移动，如果逆序的话，需要比较n(n-1)/2次，此时需要移动3n(n-1)/2次。

快速排序的排序思想是不停地确定中间的值，然后采用递归算法进行分别将两端进行排序。快速排序算法如果序列基本有序的话，快速排序退化成冒泡排序，算法时间复杂度O(n²)。如果不是基本有序的话，算法的时间复杂度为O(nlog(n)),其平均性能最好。递归使用的内存空间栈的大小最坏为O(n)，可以通过比较，先快速排序较小的那部分，，则栈的最大深度可降为O(logn)。