C++数据结构-----排序_c++里i=++n-2-优快云博客

本文详细介绍了几种经典的排序算法，包括冒泡排序、选择排序、插入排序、快速排序和希尔排序等，通过具体实例和代码解释了每种算法的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序算法：

N个数进行排序，进行N-1趟排序，第i趟排序比较N-i次，运用两个for循环实现。

代码如下：

void sort(int a[],int len,bool f)
{
		int i,j;
		for(i=1;i<len;i++)
		{
		    for(j=0;j<len-i;j++)
			{
					if((f&&a[j]>a[j+1])||(!f&&a[j]<a[j+1]))
					{
							a[j]^=a[j+1];
							a[j+1]^=a[j];
							a[j]^=a[j+1];
                     }
              }
          }
}

排序函数sort对传入的数组进行排序，len为数组长度，f决定升降序。

选择排序算法：

N个数进行排序，type a[N], 默认升序排列

1.第1趟寻找数组中最小元素与a[0]交换

2.第2趟由a[1]遍历最小元素与a[1]交换

3.第i趟由a[i-1]遍历最小元素与a[i-1]交换

总结共进行N-1趟排序，第i趟由a[i-1]遍历数组与a[i-1]交换。

void Selection_Sort(int a[],int n)
{
    int flag;
    int m;
    int i,j;

    for(i=1;i<n;i++)//进行N-1趟排序
    {
        m=a[i-1];flag=i-1;
        for(j=i-1;j<n;j++)//第i趟由a[i-1]开始遍历数组找最小的元素与a[i-1]交换
        {
            if(a[j]<m)
            {
                m=a[j];
                flag=j;
            }
        }
        a[flag]=a[i-1];
        a[i-1]=m;
    }
}

插入排序算法：

N个元素进行排序，默认升序排列。

1.a[0]与a[1]进行升序排列

2.从a[2]开始遍历，若a[i]与a[i-1]升序则继续循环。

3.若a[i]<a[i-1],则从a[i-2]往回遍历找到比a[i]小的元素，进行插入即可

void Straight_Insertion_Sort(int a[],int n)
{
     if(a[1]<a[0])
     {
         int t;
         t=a[0];
         a[0]=a[1];
         a[1]=t;
     }
     int i,j,k;
     int tmp1,tmp2;
     for(i=2;i<n;i++)//n-2次比较
     {
         if(a[i]>=a[i-1])//若升序，则继续遍历
            continue;
         for(j=i-2;j>=0;j--)//从a[i-2]往回遍历寻找插入的位置
         {
             if(a[j]<=a[i])
             {
                 k=j+1;
                 break;

             }
             if(j==0)
                k=0;
         }
         tmp1=a[k];
         a[k]=a[i];
         for(;k<i;k++)//进行插入   k,k+1,k+2,...i-1,i
                               //  i,k,k+1,k+2,...,i-2,i-1
            {
                tmp2=a[k+1];
                a[k+1]=tmp1;
                tmp1=tmp2;
            }
     }
}

N个数进行排序，共进行N-1趟排序，第i趟排序将序列中的第i+1个元素插入到一个已经按值有序的子序列（k1,k2,k3,k4,...ki）中的合适位置，使得插入后仍然有序

void iiinsert(int a[],int n)
{
       int i,tmp,j,flag;
       for(i = 1; i<n; i++)//进行n-1趟排序
       {
               tmp=a[i];
               flag=i;
               for(j = i-1; j>=0 && tmp < a[j]; j--)//将值插入到子序列中使之仍然有序
               {
                             a[flag--]=a[j]; //不断的交换直到遇到合适的位置
                             a[j]=tmp;
                }

           }
}

void insert(int a[],int n)
{
		int i,j;
		int tmp;
		for(i = 1; i<n; i++)
		{
		     tmp=a[i];
			 j=i-1;
			 while(j >= 0 && tmp < a[j])//找到tmp的插入位置
					 a[j+1]=a[j--];//将a[j]后移
            a[j+1]=tmp;//插入指定位置
        }
}

快速排序：

在当前的排序序列(k1,k2,k3,k4,k5,..)中任选一个元素作为基准元素，把小于等于基准元素的所有元素都移到基准元素的前面，把大于基准元素的所有元素都移到基准元素的后面，这样使得基准元素所处的位置恰好就在排序完成的最终位置，并且把当前参加排序的序列分成了两个子序列，对子序列进行递归排序即可。

void quicksort(int a[],int n)//快速排序
{                       //任意选取一个基准元素，把小于等于基准元素的放在前面
                        //把大于基准元素的放在后面
                        //再将两个子列进行排序.
    if(n<=1) return;
    if(n==2)
    {
        if(a[0]>a[1])
            swap(a[1],a[0]);
        return ;
    }
    swap(a[0],a[n/2]);
    int jie=a[0];
    int* L;
    int* R;
    L=a;
    R=a+n-1;
    while(L<R)
    {
        while(L<R && *L<jie) ++L;//定义左指针，不断左移
        while(R>a && *R>jie) --R;//定义右指针，不断右移
        if(L<R) swap(*L,*R);//如果两指针未交叉，就交换
    }
    if(*R<jie)//交叉后交换界值与右指针所指元素位置
    swap(a[0],*R);
    quicksort(a,R-a);//两个子序列进行递归
    quicksort(R+1,n-(R-a)-1);
}

备注：可以另外开辟一个数组实现快速排序算法。

希尔排序：又称为缩小增量排序

基本思想：设定一个元素间隔增量为gap，将参加排序的序列按这个间隔数gap从第一个元素一次分成若干子序列，进行排序，不断的缩小增量直到gap=1为止。

void shellsort(int a[],int n)
{
    int gap=n/2;
    while(gap>=1)
    {
        for(int i=0;i+gap<n;i++)
        {
            if(a[i]>a[i+gap])
                swap(a[i],a[i+gap]);
        }
        gap=gap/2;

    }
}