排序算法

一、冒泡算法优化

优势：避免了多次的不必要的排序

void bubble_sort2(sqlist *L){    int i,j;    bool flag = true;        for(i=1;i<L->length&&flag;i++)    {        flag = false;        for(j=L->length-1;j>=i;j--)        {            if(L->r[j]>L->r[j+1])            {                swap(L,j,j+1);                flag = true;            }        }           }}

二、简单选择排序

优势：减少了交换数据的次数

void simpleSelectionSort1(SqList *L)    {        int i,j,min;                              //1.进行n-1趟选择，每次选出第i小记录        for(i=1;i<L->length;i++)      {            min=i;                               //2.选择第i小记录            for(j=i+1;j<=L->length;j++)               {             if(L->r[min]<L->r[j])                    min=j;                }                            //3.与第i个记录交换            if(min!=i)           swap(L,i,min)         }}  

三、直接插入排序

优势：虽然与冒泡排序的效率相同。但它在速度上还是要高点，这是因为在冒泡排序下是进行值交换，而在插入排序下是值移动，所以直接插入排序将要优于冒泡排序。

void InsertSort(SqList *L)  {      int i,j;      for (i=1;i<L->length;i++)      {          if (L->r[i]<L->r[i-1])          {              L->r[0]=L->r[i];  //设立空位            for (j=i-1;L->r[i]>L->r[0];j--)                  L->r[j+1]=L->r[j];              L->r[j+1]=L->r[0];   //插入正确的位置        }      }  } 

四、快速排序

#include <stdio.h>#include <stdlib.h> void swap(int *x,int *y){   int temp;   temp = *x;   *x = *y;   *y = temp;}int choose_pivot(int i,int j ){   return((i+j) /2);}void quicksort(int list[],int m,int n){   int key,i,j,k;   if( m < n)   {      k = choose_pivot(m,n);      swap(&list[m],&list[k]);      key = list[m];      i = m+1;      j = n;      while(i <= j)      {         while((i <= n) && (list[i] <= key))                i++;         while((j >= m) && (list[j] > key))                j--;         if( i < j)                swap(&list[i],&list[j]);      }     // 交换两个元素的位置      swap(&list[m],&list[j]);     // 递归地对较小的数据序列进行排序      quicksort(list,m,j-1);      quicksort(list,j+1,n);   }}void printlist(int list[],int n){   int i;   for(i=0;i<n;i++)      printf("%d\t",list[i]);}void main(){   const int MAX_ELEMENTS = 10;   int list[MAX_ELEMENTS];   int i = 0;   // 产生填充序列的随机数   for(i = 0; i < MAX_ELEMENTS; i++ ){     list[i] = rand();   }   printf("进行排序之前的序列:\n");   printlist(list,MAX_ELEMENTS);      // sort the list using quicksort   quicksort(list,0,MAX_ELEMENTS-1);   // print the result   printf("使用快速排序算法进行排序之后的序列:\n");   printlist(list,MAX_ELEMENTS);}

五、归并算法

//将有序数组a[]和b[]合并到c[]中 void MemeryArray(int a[], int n, int b[], int m, int c[])  {      int i, j, k;        i = j = k = 0;      while (i < n && j < m)      {          if (a[i] < b[j])              c[k++] = a[i++];          else              c[k++] = b[j++];       }        while (i < n)          c[k++] = a[i++];        while (j < m)          c[k++] = b[j++];  }  

        可以看出合并有序数列的效率是比较高的，可以达到O(n)。

        解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

        可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

//将有二个有序数列a[first...mid]和a[mid...last]合并。  void mergearray(int a[], int first, int mid, int last, int temp[])  {      int i = first, j = mid + 1;      int m = mid,   n = last;      int k = 0;            while (i <= m && j <= n)      {          if (a[i] <= a[j])              temp[k++] = a[i++];          else              temp[k++] = a[j++];      }            while (i <= m)          temp[k++] = a[i++];            while (j <= n)          temp[k++] = a[j++];            for (i = 0; i < k; i++)          a[first + i] = temp[i];  }  void mergesort(int a[], int first, int last, int temp[])  {      if (first < last)      {          int mid = (first + last) / 2;          mergesort(a, first, mid, temp);    //左边有序          mergesort(a, mid + 1, last, temp); //右边有序          mergearray(a, first, mid, last, temp); //再将二个有序数列合并      }  }    bool MergeSort(int a[], int n)  {      int *p = new int[n];      if (p == NULL)          return false;      mergesort(a, 0, n - 1, p);      delete[] p;      return true;  }