排序算法

/*
  传递二维数组时
  void fun(int a[][3])
  或
  void fun(int (*a)[3])
*/
//void swap_num(int *a,int *b)//这里传递的是地址，*a.*b的值改变的同时 影响被传递值
void swap_num(int &a,int &b)
{
  int temp;
  /*
  temp=*a;
  *a=*b;
  *b=temp;
  */
  temp=a;
  a=b;
  b=temp;

  return;
}
void print(int a[],int n)
{
  for(int i = 0; i < n; i++)
  {
  cout<<a[i]<<" ";
  }cout<<endl;
}

1.冒泡排序

void bubble(int a[],int n)
//void bubble(int *a,int n)
{
  /*
  冒泡排序-两两交换，最小的数逐渐往上升
  时间复杂度：平均情况和最坏O(n2),最好O(n),较稳定
  */
  int i,j;
  bool change;
  for(i=0;i<n-1;i++)
  {
  change=false;//当此轮未进行swap时，说明排序完成
  for(j=n-1;j>i;j--)
  {
  if(a[j]<a[j-1])
  {
  //swap_num(&a[j],&a[j-1]);
  swap_num(a[j],a[j-1]);
  change=true;
  }
  if(!change)
  return;
  //break 跳出内部循环，执行外部循环,
  //continue结束本次循环，执行下次
  }
  }
}

2.选择排序

  void int(int a[],int n){
  /*
  选择排序,每轮寻找最小的数，放到合适的位置，需要n-1轮
  交换次数变为O(N),时间复杂度都为O(N2),不稳定
  */
  for(int i=0,j,least;i<n-1;i++)
  {
  for(j=i+1,least=i;j<n;j++)
  {
  if(a[j]<a[least])
  least=j;
  }
  swap_num(a[i],a[least]);
  }
  cout<<"the sort is selecton!"<<endl;
  print(a,n);

3.插入排序

void insertion(int a[],int n)
{
  /*
  此为插入排序
  5 1 3 8 4
  第一次 1 5 3 8 4
  第二次 1 3 5 8 4
  第三次 1 3 5 8 4
  第四次 1 3 4 5 8
  插入排序平均时间复杂度为O(N2)，但是它要比冒泡排序快一倍，
  比选择排序还要快一点，经常被用在较复杂的排序算法的最后阶段，例如快速排序。
  算法是稳定的
  */
  for(int i=1,j;i<n;i++)
  {
  int tmp=a[i];
  for(j=i;j>=0;j--)
  {
  if(a[j-1]>tmp)
  a[j]=a[j-1];
  }
  a[j]=tmp;
  }
  cout<<"the sort is insertion!"<<endl;
  print(a,n);
｝

4.希尔排序

void shell_Sort(int a[],int n)
{
    int i,j,tmp,k;
    int gap[20];
    gap[0]=1;
    for(i=1;gap[i]<n;i++)
    {
        gap[i]=3*gap[i]+1;//根据研究，表明这个增量序列比较合适，或者直接每次gap/2也可以
    }
    for(i--;i>=0;i--)//gap[]增量数组
    {
        for(j=gap[i];j<n;j++)//
        {
            tmp=a[j];
            for(k=j-gap[i];k>=0&&a[k]>tmp;k=k-gap[i])
            {
                a[k+gap[i]]=a[k];
            }
            a[k+gap[i]]=tmp;
        }
    }
    print(a,n);
    /*gap = n/2;
    while(gap>0)
    {
      for(i = gap;i<n;i++)
     {
        j=0;
        tmp=a[i];
        for(j=i-gap;j>=0&&a[j]>tmp;j=j-gap)
        {
            a[j+gap]=a[j];
        }
        a[j+gap]=tmp;


      }
      gap=gap/2;
    }
    */


}

5.快速排序

void quicksort(int a[],int l,int r)//注意l,r是数组的角标值
{

     int i,j,tmp;
     if(l>=r)
        return;
     tmp=a[l];
     i=l;j=r;
     while(i<j)
     {
         while(i<j&&a[j]>=tmp)//从右边开始找一个比基数小的数
            j--;
         while(i<j&&a[i]<=tmp)//从左边找比基数大的数
            i++;
         if(i<j)
         Swap(&a[i],&a[j]);//交换位置
     }
     a[l]=a[i];
     a[i]=tmp;//将基数归位
     quicksort(a,l,i-1);
     quicksort(a,i+1,r);
}

6.归并排序

void mergeArray(int a[],int first,int last)
{
    int mid=(first+last)/2;
    int i=first,j=mid+1,temp[100],k=0;
    while(i<=mid&&j<=last)//左右数组都包含元素
    {
//        if(a[i]<=a[j])
          temp[k++]=a[i++];
        else temp[k++]=a[j++];
    }
     //将剩余元素导入temp[]
     while(i<=mid)
            temp[k++]=a[i++];
     while(j<=last)
            temp[k++]=a[j++];
    //将temp元素导入到a[]中
    for(i=0;i<k;i++)
        a[first+i]=temp[i];//*******一定要写first+i;**********

}
void mergeSort(int a[],int first,int last)
{
    if(first<last)//至少含有两个元素
    {
        int mid=(first+last)/2;//划分成两组
        mergeSort(a,first,mid);//左边有序
        mergeSort(a,mid+1,last);//右边有序
        mergeArray(a,first,last);
        //将两个有序数列合并

    }
}