内部排序汇总

插入排序

 

直接插入排序

/* 直接插入排序 */
void insertSort(int a[], int n)
{
	int i,j;
	for (i=2;i<=n;i++) // 依次将a[i]插入到前面已排序序列
	{
		if (a[i]<a[i-1]) // 若a[i]小于其前驱，才需将a[i]插入有序表
		{
			a[0]=a[i]; // 复制为哨兵
			for (j=i-1;a[0]<a[j];--j) // 从后往前查找插入位置
			{
				a[j+1]=a[j]; // 向后挪位
			}
			a[j+1]=a[0]; // 复制到插入位置
		}
	}
}

 

希尔排序

直接插入排序的时间复杂度为O(n²)，但若待排序序列为正序时，其时间效率可提高至O(n)。希尔排序从以下两点分析出发对直接插入排序进行改进：

• 由于直接插入排序算法简单，则在n值很小时效率也比较高；
• 若待排序序列按关键字“基本有序”时，直接插入排序的效率可大大提高。

/* 希尔排序 */
void shellSort(int a[], int n)
{
	// 对顺序表作希尔插入排序，本算法和直接插入排序相比，做了一下修改：
	// 1> 前后记录位置的增量为dk，不是1
	// 2> a[0]只是暂存单元，不是哨兵，当j<0时，插入位置已到
	int dk,i,j;
	for (dk=n/2;dk>=1;dk=dk/2) // 步长变化
	{
		for (i=dk+1;i<=n;i++)
		{
			if (a[i]<a[i-dk]) // 需将a[i]插入到有序增量子表
			{
				a[0]=a[i]; // 暂存在a[0]
				for (j=i-dk;j>0&&a[0]<a[j];j-=dk)
				{
					a[j+dk]=a[j]; // 记录后移，查找插入的位置
				}
				a[j+dk]=a[0]; // 插入
			}
		}
	}
}

交换排序

 

冒泡排序

/* 冒泡排序 */
void bubbleSort(int a[], int n)
{
	int i,j;
	for (i=0;i<n-1;i++) // 共有n-1趟排序
	{
		bool flag=false; // 表示本趟冒泡是否发生交换的标志
		for (j=0;j<n-i-1;j++) // 一次冒泡过程
		{
			if (a[j]>a[j+1])
			{
				swap(a[j],a[j+1]);
				flag=true;
			}
		}
		if (flag==false)
		{
			break; // 本趟遍历后没有发生交换，说明表已经有序
		}
	}
}

 

快速排序

参考之前文章：快速排序

// 一趟快速排序，划分 
int partition(int a[],int low,int high) 
{ 
    int i=low,j=high; 
    int x = a[i]; 
    while (i!=j) 
    { 
        while (a[j]>=x && i<j) j—; 
        if (i<j) { a[i]=a[j]; i++; } 
        while (a[i]<=x && i<j) i++; 
        if (i<j) { a[j]=a[i]; j—; } 
    } 
    a[i]=x; 
    return i; 
}

/* 快速排序 */
void quickSort(int a[],int low,int high)
{
    if (low<high)
    {
        int k = partition(a,low,high);
        quickSort(a,low,k-1);
        quickSort(a,k+1,high);
    }
}

选择排序

 

简单选择排序

/* 简单选择排序 */
void selectSort(int a[], int n)
{
	int i,j,min;
	for (i=0;i<n-1;i++) // 共进行n-1趟
	{
		min=i; // 记录最小元素位置
		for (j=i+1;j<n;j++) // 在a[i...n-1]中选择最小的元素
		{
			if (a[j]<a[min])
			{
				min=j; // 更新最小元素位置
			}
			if (min!=i)
			{
				swap(a[i],a[min]); // 最小元素与第i个位置交换
			}
		}
	}
}

 

堆排序

参考之前的文章：堆排序

/* 向下调整，即筛选 */
void adjustDown(int a[], int start, int n)
{
	// 根结点编号为1，对第start个元素进行调整
	a[0]=a[start]; // a[0]暂存
	for (int i=2*start;i<=n;i*=2) // 沿较大的子结点向下筛选
	{
		if (i<n&&a[i]<a[i+1])
		{
			i++; // 取较大的子结点的下标
		}
		if (a[0]>=a[i])
		{
			break; // 筛选结束
		}
		else
		{
			a[start]=a[i]; // 将a[i]调整到双亲结点上
			start=i; // 修改start，以便继续向下筛选
		}
	}
	a[start]=a[0]; // 被筛选结点的值放入最终位置
}

/* 堆排序 */
void heapSort(int a[], int n)
{
	for (int i=n/2;i>0;i--) // 1> 初始建堆，从i=n/2 --> 1，反复向下调整
	{
		adjustDown(a,i,n);
	}

	for (int j=n;j>1;j--) // 2> n-1趟的交换和建堆过程
	{
		swap(a[j],a[1]); // 输出堆顶元素（和堆底元素交换）
		adjustDown(a,1,j-1); // 把剩余的j-1个元素整理成堆
	}
}

二路归并排序

参考之前的文章：二路归并排序

// 一趟归并排序算法
int b[N];
void merge(int a[],int left,int mid,int right)
{
    // 表a的两段a[left..mid]和a[mid+1..right]各自有序，将它们合并成一个有序表
    for (int m=left;m<=right;m++)
        b[m] = a[m];                    // 将a中所有元素复制到b中
    for (int i=left,j=mid+1,k=i;i<=mid&&j<=right;k++)
    {
        if(b[i]<=b[j])                    // 比较b的左右两段中的元素
            a[k]=b[i++];                // 将较小值复制到a中
        else
            a[k]=b[j++];
    }
    while (i<=mid)      a[k++]=b[i++];    // 若第一个表为检测完，复制
    while (j<=right)  a[k++]=b[j++];    // 若第二个表为检测完，复制
    // 最后两个while循环只有一个会执行
}

/* 二路归并排序 */
void mergeSort(int a[],int left,int right)
{
    if (left < right)
    {
        int mid = (left+right)/2;    // 从中间划分两个子序列
        mergeSort(a,left,mid);        // 对左侧子序列进行递归排序
        mergeSort(a,mid+1,right);    // 对右侧子序列进行递归排序
        merge(a,left,mid,right);    // 归并
    }
}

总结