排序算法： 冒泡排序， 快速排序，希尔排序,直接插入排序 ，直接选择排序,归并排序,堆排序

几种排序算法分析：

 

  冒泡排序：

  冒泡排序的方法排序速度比较慢。

  思路：进行n-1排序，第一次排序先找出最小的数字，放在第一个位置，然后在剩余的数字中再找出最小的数字，放在第二个位置上，依次类推，可以排出所有的数字。

  当然也可以从大到小的排序。

  例如 a[]={5 ,4 ,3, 2, 1};

    

   void maopao(int a[] ,int n)

{

           int i , j, tmp;

           for(i = 0 ;i <n-1 li++)

         

        {

                  for(j = 0 ;j <n-1-i ; j++)

                   {

                        if(a[j]>a[j=1])

                         {

                                 tmp = a[j];

                     a[j] = a[j+1];

a[j+1] = tmp;

                         }

                  }

        }

}

  冒泡排序的时间复杂度是，最好的情况下为 n-1  即O(n)    交换次数为 0

  最坏的情况下的时间复杂度为 进行n-1排序 第一次排序 需要进行n-1 次遍历，第二次排序需要遍历n-2次遍历 ，依次类推 一直到 1次遍历。

   (((n-1)+1)/2)*(n-1); 时间复杂度为 O(n^(2))  。交换次数为 (((n-1)+1)/2)*(n-1)*3 。

平均的时间复杂度为 O(n^(2)) 。

冒泡排序属于稳定的排序算法。

 

 快速排序：

  

 快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

     a[N] ={ 3 , 2 , 4 , 5 , 1};

    i j,

   i=0;

  j = 4;

     首先要先确定第一次比较的基准值，一般是选择第一个数据作为基准值，选择  a[0] = 3 作为 temp = 3;

     从数组后面开始比较

     a[4]< tmp  那么把a[4]设置为 3  a[0]设为1

    此时变为 ： { 1 ， 2 ，4 ，5 ，3}

   这时从数组前面开始比较

     a[0]< 3 ,a[1]<3 ,只有a[2]>3 .此时把 a[2 ]设为 3 ，a[4]设置为 4

  此时变为

     { 1 ,2 ,3, 5, 4}

   此时的     从后边开始 a[3]= 5 >3 , j--

 此时 i = 2 ，j = 2 不符合  i<j条件，本次阶数

最后结果为

   {1 ,2 , 3, 5,4}

 这样就 把数组分成了两组 ，再用此类方法分别对这两个组进行 这种排序，最后得到是;

 { 1,2,3,4,5}

     具体的代码如下：

   

void quicksort(int a[],int left ,int right)
{
 int i ,j ,tmp;
 i = left ;
 j = right;
 tmp = a[left];
 if(left > right)
 {
  return;
 }
 while(i != j)
 {
  while(a[j]>=tmp && j>i)
  {
   j--;
  }
  if(j>i)
  {
   a[i++] = a[j];
  }
  while(a[i]<=tmp && j>i)
  {
   i++;
  }
  if(j>i)
  {

   a[j--] = a[i];
  }
 }
 a[i] = tmp;
 quicksort(a,left ,i-1);
 quicksort(a,i+1 ,right);<