常用排序算法C++代码实现

**

废话少说，长驱直入

**
数据结构 推荐 浙大陈越姥姥和何钦铭老师的课程
1.冒泡排序
冒泡排序：核心是两层循环，强调出现小值就交换。
每次循环得到此次最大值放在数组尾部，也就是从后向前建立有序的算法。

void BubbleSort(int arr[],int length)
{
    for(int i=0;i<length-1;i++)//只需比较元素个数-1次
    {
        int flag=0;//建立一个flag，如果某一次内层循环执行完之后没有发生元素交换，则已经有序，直接跳出循环，排序完成
        for(int j=0;j<length-i-1;j++)//每次减少一次
        {
            int tem=0;
            if(arr[j]>arr[j+1])
            {
                //冒泡排序强调在内层循环内出现小值就交换
                tem=arr[j+1];
                arr[j+1]=arr[j];
                arr[j]=tem;
                flag=1;
            }
        }
        if(flag==0)
        break;
    }

}

2.选择排序
选择排序：选择排序重点是每一趟排序都选择出此趟的最小值，将其放在此趟排序的第一个位置，是一种从前往后建立有序的算法。

void SelectSort(int arr[],int length)
{
    int tem=0;
    for (int i=0;i<length-1;i++)
    {

       for(int j=i;j<length;j++)
       {
            int minIndex=i;
            if(arr[i]>arr[j])
        {
            minIndex=j; //选择排序强掉先记录最小值的索引，在外层循环再交换

        }
       //在外层循环再交换 
        tem=arr[minIndex];
        arr[minIndex]=arr[i];
        arr[i]=tem;

       }
    }
}

3.插入排序
插入排序：插入排序也是一种从前往后建立有序的算法，它不同于选择排序的是：选择排序每次在子列中选出最小值，而插入排序则认为待排元素之前的子列是有序的，将待排元素与其之前的有序子列中的每一个元素从后往前进行比较，比较过程类似冒泡排序，最终找到其位置。

void insertSort(int array[], int n)
{
    int i,j,temp;
    for( i=1;i<n;i++)
    {
        int minIndex=i;
        for(int j=i-1;j>=0;j--)//每次与前面已经有序的进行比较
        {
            if(array[minIndex]<array[j])//此过程类似冒泡排序
            {
                temp=array[minIndex];
                array[minIndex]=array[j];
                array[j]=temp;
                minIndex=j;
            }
        }
    }
}

4.归并排序
归并排序：归并排序采用分而治之的策略，将原始数组递归二分为单个元素，然后再从最小单元往上两两部分比较排序合并。下面使用递归完成归并排序。

**引用自菜鸟**

//对于***治***
void Merge(int array[], int temp[],int L,int R,int RightEnd)//temp[]临时数组，存放合并后的元素
{
	 int LeftEnd, NumElements, Tem;
     LeftEnd = R - 1; //左边终点位置
     Tem = L;         //有序序列的起始位置
     NumElements = RightEnd - L + 1;

     while( L <= LeftEnd && R <= RightEnd ) {
         if ( array[L] <= array[R] )
             temp[Tem++] = array[L++]; //将左边元素复制到temp
         else
             temp[Tem++] = array[R++]; // 将右边元素复制到temp
     }
    //如果左右子列不一样长，那么要判断哪一个还没遍历完
     while( L <= LeftEnd )
         temp[Tem++]  = array[L++];// 直接复制左边剩下的 
     while( R <= RightEnd )
          temp[Tem++] = array[R++];  // 直接复制右边剩下的

     for( int i = 0; i < NumElements; i++, RightEnd -- )
         array[RightEnd] = temp[RightEnd]; // 将有序的temp[]复制回array[]
}

//***分***
void MSort(int array[],int temp[],int L,int RightEnd)
{
	int Center;

     if ( L < RightEnd )
      {
          Center = (L+RightEnd) / 2;
          Msort( array, temp, L, Center );              // 递归解决左边
          Msort( array, temp, Center+1, RightEnd );     // 递归解决右边
          Merge( array, temp, L, Center+1, RightEnd );  // 合并两段有序序列 
     }
}
//**统一接口**
void MergeSort(int array[],int length)
{
      int temp[length];
      Msort( A, temp, 0, length-1 );
 }

5.快速排序
快速排序：分而治之的思想，由于快排需要把一组数据分成左右两个部分，一部分小于主元（即在数组中选取的参照），一部分大于主元，主元的选取影响排序算法的快慢，所以快排需要注意主元的选取（一般可用取头中尾的中位数）。

//交换函数
void Swap(int *a,int *b)
{
    int tem;
    tem=*a;
    *a=*b;
    *b=tem;
}

//
/*******************快速排序******************/

/*******************首先写下选取主元的函数******************/
int SelectPivot(int array[],int l, int r)
{
    int center=(r+l)/2;
    if(array[l]>array[center])
    Swap(&array[l],&array[center]);
    if(array[l]>array[r])
    Swap(&array[l],&array[r]);
    if(array[center]>array[r])
    Swap(&array[center],&array[r]);
    //经过上面的操作已经保证头中尾按从小到大排列
    Swap(&array[center],&array[r-1]);//这里先将中间大的值放在最右边的前一个位置，这样后续进行左右子集划 分时就只需要考虑0~倒数第2个元素
    return array[r-1];
}
/*******************递归实现函数******************/
void QuickSortDevice(int arr[],int left,int right)
{
   //首先判断是否此次递归传入的是否只有2个元素，若只有两个，则无需再调用SelectPivot函数，直接比较调换
    if((right-left)<=1)
    {
        if(arr[left]>arr[right])
        {
            Swap(&arr[left],&arr[right]);
            return;
        }
        else
        return;
    }
    //元素多于两个时，采取选主元—>进递归方法
    int tem=SelectPivot(arr,left,right);//选主元
    int i=left;//相当于头“指针”
    int j=right-1;//相当于尾“指针”

    if(i>=j)return;
    int flag=0;//设置一个哨兵元素，来切换头尾遍历顺序，且要保证从尾开始遍历

    while(i<j)
    {
        if(flag==0)//先从尾开始
        {
            if(arr[i]>tem)
            {
                Swap(&arr[i],&arr[j]);
                j--;
                flag=1;
            }
            else i++;
        }
        else//尾部发生交换后就切换至从头开始
        {
            if(arr[j]<tem)
            {
                Swap(&arr[i],&arr[j]);
                i++;
                flag=0;
            }
            else j--;
        }
    }
    QuickSortDevice(arr,left,i-1);//左半部分递归
    QuickSortDevice(arr,i+1,right);//右半部分递归
}

/*******************快速排序统一接口******************/
void QuickSort(int arr[],int length)
{
    QuickSortDevice(arr,0,length-1);
}

6.希尔排序
希尔排序：由于冒泡排序每次只比较相邻元素，所以总体来说比较次数多，排序慢，而希尔排序通过设置一个增量（增量在最后一次循环时一定要为1），大跨度比较元素然后进行交换，这种情况可以实现交换一次就让多个元素有序。

//交换函数
void Swap(int *a,int *b)
{
    int tem;
    tem=*a;
    *a=*b;
    *b=tem;
}
void ShellSort(int arr[],int n)
{
    int Incresement=n/2;//设置一个增量
    int tem;
    //一下过程类似冒泡
    for(;Incresement>0;)
    {
      for(int i=0;i<n-Incresement;i++)
    {
        if(arr[i]>arr[i+Incresement])
        {
            Swap(&arr[i],&arr[i+Incresement]);
        }
    }  
    Incresement-=1;
    }
}

refreshing…